Metaplay vs PlayFab: Which Game Backend Should You Choose?

If you are choosing a game backend, the Metaplay vs PlayFab decision comes down to one structural trade-off: PlayFab is a fully managed Microsoft Azure SaaS you call over REST, while Metaplay ships its backend as source code and runs it for you on Metaplay Cloud, a managed service on AWS, with server-authoritative C# logic shared between the Unity client and the .NET server. PlayFab is the older and more turnkey platform with a broader engine and feature surface; Metaplay is source-available and Unity-first. This guide walks through architecture, LiveOps, the economy, analytics, and what each one costs.

Metaplay vs PlayFab at a glance

Category	Metaplay	PlayFab
Player management	Device, email, social auth; PlayerModel state synced client/server; segment on any player property	Device, email, social, Xbox, PSN, Nintendo auth; key/value player data; real-time PlayStream segmentation
LiveOps	A/B testing, OTA game configs, scheduled live events, player segments, all editable in source	Experiments (up to 9 variants), Title Data, scheduled tasks, PlayStream rules
Economy	Server-authoritative currencies and inventory; App Store, Google Play and Steam receipt validation	Economy v2; up to 10,000 items per collection; multi-store validation; idempotent redeem APIs
Multiplayer	Async MMR matchmaker and custom multiplayer entities; no real-time netcode or built-in voice	Multiplayer Servers, matchmaking, lobbies, and Party SDK for cross-platform voice and text
Analytics	Built-in tracking and dashboards; stream events to BigQuery or S3	PlayFab Insights Management deprecated Dec 2023; analytics now run through Azure Data Explorer
Infrastructure	Metaplay Cloud (managed by Metaplay on AWS); self-host in your own AWS account via Private Cloud (Terraform/Helm, EKS/RDS/S3/CloudFront)	Azure SaaS; Microsoft hosts and operates everything
Operations dashboard	LiveOps Dashboard shipped as Vue source you can extend	Game Manager: 80+ permissions (grouped into roles), closed and not customizable
Engines	Unity-first (C#, shared logic); Unreal and custom engines via API only	Unity, Unreal, C/C++, console SDKs, and REST
State authority	Server-authoritative by default; deterministic shared logic with checksum validation	Client SDKs by default; server authority is opt-in via CloudScript or Azure Functions
AI and developer tooling	Metaplay Agent (public preview) plus Docs and Portal MCP servers; no in-game ML	PlayFab Copilot (private preview, GDC 2024); Azure-backed in-game ML: churn prediction, AI moderation, Party speech
Pricing	€195/mo Starter; €1,985/mo + €2.95 per 1,000 DAU per day in Production	Free dev tier (1,000 lifetime players/title); $99–$10k+/mo tiers plus usage meters; free under Foundation Mode

Who builds on each platform

PlayFab launched in 2014 and was acquired by Microsoft in 2018. It is one of the oldest and most widely deployed game backends, and Microsoft runs its own titles on it, including Minecraft, Sea of Thieves, and Microsoft Flight Simulator. As a managed SaaS inside the Azure Gaming ecosystem, it gives you authentication, player data, an economy, leaderboards, multiplayer servers, and LiveOps tooling through REST APIs and a dozen native SDKs, so a small team can wire up a backend without provisioning a single server.

Metaplay was founded in 2019 by people with backgrounds in the game and software industries and ships its backend as source code that it runs for you on its managed cloud. The defining design choice is shared game logic: you write your gameplay rules once in C#, and the same code compiles into both the Unity client and the .NET server. The server keeps authority over all game state, validates every action with checksums, and resyncs the client on the rare divergence. Studios building on Metaplay include Metacore, Trailmix, and Lessmore.

Both platforms run real live-service games in production, and their designs target different team setups. PlayFab suits a studio that wants Microsoft to operate the backend and builds gameplay logic on top of REST calls. Metaplay suits a Unity team that wants to own the code, make cheating structurally hard, and run an economy-driven live game where client responsiveness and server authority both matter.

Architecture: shared C# logic vs a managed REST platform

Aspect	Metaplay	PlayFab
Server language	C# (.NET)	Managed service; no server runtime you write or host
Client SDKs	Unity (C#); Unreal and custom engines via API	Unity, Unreal, C/C++, C#, console SDKs, REST
State authority	Server-authoritative by default	Client SDK by default; server validation is opt-in
Custom server logic	Direct C# in the shared codebase	CloudScript (Azure Functions) for serverless logic
Hosting	Metaplay Cloud (managed on AWS); self-host via Private Cloud	Microsoft Azure only

PlayFab runs entirely on Azure. Your game connects to PlayFab's APIs for identity, player data, the economy, and LiveOps, and Microsoft operates every part of the infrastructure behind those APIs. For custom logic you write CloudScript backed by Azure Functions, which runs serverless in the language of your choice and reacts to PlayStream events. Dedicated game servers for real-time multiplayer are available through Multiplayer Servers, billed separately by compute.

PlayFab is not flatly "client-authoritative with no source." Its client SDKs for Unity, Unreal, C/C++, and C# are open-source on GitHub, generated by a tool you can fork, and server authority is available. You opt into it through CloudScript, Azure Functions, server-only APIs gated by secret keys, and API access policies that restrict what clients can call. What you do not get is the server runtime or the Game Manager source; those are closed and operated by Microsoft. PlayFab clients talk to a closed managed backend, and server-side enforcement is something you add deliberately rather than the default.

Metaplay compiles your game logic into both the Unity client and the .NET server. When a player takes an action, it runs locally first so the UI responds immediately, then the server replays the same deterministic code, validates the result with a checksum, and persists it. If the client and server ever diverge, the server wins and the client resyncs.

Under this model a chunk of your game logic lives in both binaries and has to stay deterministic, with no wall-clock time, no unseeded randomness, and no floating-point drift. In exchange, an entire layer of client networking code disappears (the request queue, the retry loop, the wait-for-response plumbing) and tampering with client state cannot move the server's view of the game.

It does not stop every cheat (bots and automation still need their own detection), but it makes the most common economy exploits structurally impossible rather than something you patch after launch. See the Metaplay architecture overview for the full model.

AI and developer tooling: build-time assistants vs in-game ML

AI appears in two places here: tooling that helps your team build the game (assistants, codegen, MCP servers) and ML that runs inside your live game (churn scoring, moderation, speech). The two platforms take opposite approaches. Metaplay invests in build-time tooling and ships no in-game ML; PlayFab ships generally available in-game ML through Azure but keeps its developer assistant in limited preview.

Dimension	Metaplay	PlayFab
Build-time AI tooling	Metaplay Agent (public preview) installs SDK skills that turn Claude Code or Cursor into a Metaplay developer; Docs and Portal MCP servers expose docs, SDK source, and live infrastructure; MetaplayGPT answers docs questions	PlayFab Copilot, a natural-language assistant in Game Manager, was shown at GDC 2024 entering private preview with no documented general availability since
In-game AI / ML	None built in; matchmaking, segmentation, and experiments are rules- and config-based, and analytics stream to your own warehouse for you to model	Churn Prediction (Azure ML) scores players and feeds segmentation; Party adds speech-to-text, text-to-speech, and 100+ language translation; text moderation runs on Azure AI Content Safety, with ToxMod voice moderation being added

Because you own the source, an AI agent reads the system it is changing rather than working against an API surface alone. The Metaplay Agent installs SDK skills so a coding agent works like a Metaplay developer, and the MCP servers feed documentation, SDK source, and live game infrastructure straight into the tools your engineers already use. The Agent is in public preview, and the runtime systems it helps you build stay rules-based, not ML-driven.

PlayFab approaches AI from the live-game side. Churn Prediction is powered by Azure Machine Learning and feeds straight into segmentation, and Party layers in speech and translation alongside text moderation backed by Azure AI Content Safety. Its developer-facing assistant, PlayFab Copilot, is still in private preview (announced GDC 2024). PlayFab includes in-game ML through Azure: churn prediction that feeds segmentation, plus text and voice moderation. Metaplay includes no in-game ML; its AI investment is build-time tooling (the Metaplay Agent and MCP servers), and analytics stream to your own warehouse for you to model.

LiveOps: editable game configs vs Microsoft's experimentation stack

Capability	Metaplay	PlayFab
A/B testing	Experiments on game-config variants with rollout %, capacity caps, and segment targeting	Experiments with up to 9 variants on Microsoft's platform; 95% confidence and sample-ratio-mismatch detection
Remote config	Game Configs from Google Sheets or CSV, published over-the-air, any data structure	Title Data key/value pairs (primary, internal, override) changeable without a build
Scheduled content	LiveOps timeline with calendar scheduling, recurrence, and UTC or local modes	Scheduled tasks on Cron expressions at 5-minute intervals
Player segmentation	Segments on any player property, editable in source	Real-time segmentation on PlayStream events with AND/OR filters that trigger actions
Dashboard customization	Vue source shipped; add game-specific pages and actions	Game Manager is closed; extend behavior via CloudScript, not the UI

This is where the source-vs-SaaS split is most concrete. PlayFab's Experiments run on Microsoft's internal experimentation platform, with statistical machinery (sample-ratio-mismatch detection and 95% confidence reporting) that you would otherwise build yourself. Its segmentation reacts to PlayStream events in real time and can fire actions automatically. These run as managed services rather than something you build.

The platforms diverge when you need behavior the platform does not offer out of the box. On Metaplay every LiveOps system ships as source, so changing how a segment is evaluated or how an experiment buckets players is a code edit in a codebase you own, not a support ticket or a feature request. Game Configs publish over-the-air with no client update, and the LiveOps Dashboard is Vue you can extend with game-specific pages. PlayFab ships the experiment statistics as a managed service; Metaplay ships the LiveOps systems as source you can change directly.

Player management and authentication

Both platforms cover standard authentication: anonymous device login, email and password, and the major social providers (Google, Apple, Facebook, Steam), with account linking for cross-platform identity. They diverge at the console edge. PlayFab ships native first-party authentication for Xbox Live, PlayStation Network, and Nintendo, consistent with its Xbox lineage. Metaplay supports console deployment but expects you to wire up the platform-specific auth flows yourself.

They also differ in how player state is modeled. PlayFab stores player data as key/value pairs split across title-specific and cross-title publisher data, plus Entity Objects and Game Saves for larger blobs. Metaplay keeps all player state in a strongly typed PlayerModel that the server owns and synchronizes to the client, with automatic persistence after critical actions like purchases. For a game with rich, evolving player state (an economy, progression, and inventory all interacting), the two approaches differ in how the state is structured and where authority sits.

Economy: server-authoritative by default vs Economy v2

Feature	Metaplay	PlayFab Economy v2
Virtual currencies	Multiple types, server-validated via player actions	Soft and hard currencies with initial deposits and optional recharge
Inventory scale	Configurable, stored in PlayerModel collections	Up to 10,000 items per collection, with stacks and batch operations
Catalog size	Configurable, data-driven from game configs	Unified catalog up to 20 GB
IAP validation	App Store, Google Play, and Steam, server-side	iOS, Google Play, Amazon, and Windows Store
Transaction authority	Server-authoritative: earn, spend, grant, and validate all run server-side	Idempotent redeem APIs prevent double-charging and fraud
Source access	Yes, modify any economy behavior	Client SDKs are open-source; the economy service itself is closed

PlayFab's Economy v2 went to public preview in 2022 and reached general availability in 2023, and it powers Minecraft's economy. It handles large inventories (up to 10,000 items per collection), a unified catalog up to 20 GB, and idempotent redeem APIs that make double-spend and receipt fraud hard. It is documented and generally available.

On Metaplay the economy is server-authoritative as a property of the architecture rather than a feature you switch on. Every transaction (earning, spending, granting items, validating receipts) executes on the server through validated player actions. The client can show the expected result immediately for responsiveness, but the server determines the real outcome. For an economy-driven live game that distinction matters: a tampered client cannot grant itself currency, because the grant only counts when the server replays the same deterministic code and agrees.

Analytics: built-in vs Azure Data Explorer

The two platforms differ in where analytics live. Microsoft deprecated PlayFab Insights Management on 11 December 2023 and now points studios at Azure Data Explorer, which means standing up and paying for ADX infrastructure to get the kind of analytics that used to be in the box. PlayFab still ships pre-generated revenue reports, so basic monetization metrics are covered, and anything custom now lives in Azure tooling you operate.

Metaplay includes built-in player behavior tracking, revenue analytics, and per-player event logs in the dashboard, and streams analytics events to BigQuery, S3, or GameAnalytics so your data team works in the warehouse they already use. There is no built-in ML on top of it (if you want churn prediction you model it yourself downstream), but you are never blocked from your own raw event stream.

Multiplayer: async matchmaking vs Multiplayer Servers and Party

For real-time multiplayer, PlayFab provides dedicated Multiplayer Servers, ticket-based matchmaking, and Party voice/chat. Metaplay has no synchronous real-time matchmaker or built-in voice; real-time games integrate a netcode layer such as Photon alongside it. PlayFab's dedicated Multiplayer Servers host containerized game servers on Azure with standby pools and sub-second allocation, ticket-based matchmaking with up to 20 rules per queue and backfill, and the Party SDK adds cross-platform voice and text chat with speech-to-text and translation built in. That covers shooters and other titles with real-time netcode and in-game voice in a single hosted stack.

Metaplay targets a different shape of multiplayer. It provides an async MMR matchmaker that uses buckets for fast opponent lookup, and multiplayer entities for server-driven battles and matches that pass messages across a distributed cluster. It has no real-time physics netcode or built-in voice and chat; those come through integration. That covers turn-based, async-PvP, and economy-driven games; twitch real-time multiplayer runs on PlayFab's hosted stack or on a dedicated netcode layer integrated alongside Metaplay.

Pricing: usage meters vs DAU tiers

The two pricing models work differently enough that a single headline number misleads. PlayFab charges by usage against tiered meter credits; Metaplay charges a flat platform fee plus a per-DAU licence billed daily.

PlayFab pricing

Tier	Base cost	Includes
Development	Free	Up to 1,000 lifetime players per title
Pay-as-you-go	$0/mo	Usage-billed only
Standard	$99/mo	$400/mo in included meter credits
Premium	$1,999/mo	$8,000/mo in included meter credits
Enterprise	$10,000+/mo	Custom

On top of the base tier you pay metered usage. The meters that matter most for a live game:

• PlayStream events: $6.60 per million
• Profile reads: $0.33 per million
• Profile writes: $7.15 per million
• Economy v2 inventory reads: $3.00 per million
• Economy v2 inventory writes: $40.00 per million
• Multiplayer Servers: billed separately by compute

The write-side Economy meter is the largest variable. At $40.00 per million inventory writes, an economy with heavy item churn can dominate the bill in a way profile reads do not, and a tier's included credits may not cover it.

There is also a path that takes PlayFab's cost to zero. At GDC 2026 Microsoft introduced Foundation Mode, under which core PlayFab services are free for games shipped under an Xbox publishing agreement. (Foundation Mode arrived alongside a March 2026 cut to the free Development tier, from 100,000 to 1,000 lifetime players per title; the two coexist.) For a title going through Xbox publishing, that changes the math: PlayFab's backend becomes part of the publishing deal rather than a separate line item. See PlayFab pricing for current meters and tiers.

Metaplay pricing

Tier	Price	Includes
Free	€0/mo	Local development, full SDK
Starter	€195/mo	1 mini environment, cap 5 DAU
Pre-Launch	€995/mo	2 small environments, cap 100 DAU
Production	€1,985/mo + €2.95 per 1,000 DAU per day	Staging + production environments; first 5,000 DAU/day included
Private Cloud	Custom (Enterprise)	Self-hosted, €2 per 1,000 DAU; positioned for >1M DAU

Every feature is included in every paid tier, with no add-on pricing for source access, LiveOps, or the economy. The DAU licence is billed daily, not monthly. The €2.95 per 1,000 DAU is a daily fee that is multiplied across the month, and the first 5,000 DAU each day are free. Metaplay's own worked example on the pricing page spells it out:

A game with 100,000 DAU every day in a 30-day month: daily billable DAU = 100,000 − 5,000 = 95,000 → daily licence fee = 95,000 ÷ 1,000 × €2.95 = €280.25 → monthly licence fee = €280.25 × 30 = €8,407.50 → total = €1,985 + €8,407.50 = €10,392.50/month.

So the formula for a sustained daily DAU of D (where D ≥ 5,000) is 1,985 + ((D − 5,000) / 1,000) × 2.95 × 30.

Cost comparison at 100,000 DAU

Platform	Estimated monthly cost
Metaplay (Production)	€10,392.50 (€1,985 base + 95,000 ÷ 1,000 × €2.95 × 30)
PlayFab (usage-based)	Premium $1,999/mo base, then metered; total swings with read/write and event volume
PlayFab under Foundation Mode	Effectively €0 for core services if shipped under an Xbox publishing agreement

At high DAU, Metaplay's per-day licence adds up, and the bill is a function of one number you already track (DAU) rather than the volume of inventory writes and PlayStream events a design generates. PlayFab's usage model can be lower at low or spiky volume, especially on the free dev tier or under Foundation Mode, and higher and harder to forecast once a busy economy drives heavy write-meter traffic. The two models trade a flat, DAU-linked bill against a usage-linked one. See Metaplay pricing for the live worked example and current tiers.

Seen in isolation, €10,392.50/month can look steep. In hiring terms it is close to the fully loaded cost of a single experienced backend engineer. The alternative to a managed platform is building and operating these systems in-house, which means staffing a full backend and DevOps team for the life of the game. Among the options here, Metaplay is the only one that delivers a source-available backend as a managed service, so a studio gets those systems without building that team and without lock-in. Metaplay's own analysis puts the cost of an in-house backend build at around $21M over a typical multi-year build: The true cost of building your own backend.

Key differences in source access, deployment, and engine support

Three structural differences tend to decide the choice, beyond any single feature.

Source access and lock-in come first. Metaplay ships full source for the C# server, the Unity SDK, and the Vue dashboard in every paid tier: you can read, modify, debug, and extend any part, and if you ever leave, you keep the code and fork it. PlayFab's client SDKs are open-source on GitHub and you can customize them, but the server runtime and Game Manager are closed and operated by Microsoft, so leaving PlayFab means exporting your player data and rebuilding backend logic elsewhere.

Then there is deployment and data ownership. By default Metaplay runs your backend on Metaplay Cloud, a managed service it operates on AWS, so there is no infrastructure for you to run; because you hold the source, you can also self-host in your own AWS account via the Private Cloud plan and put the data in infrastructure you control. PlayFab is Azure-only and Microsoft-operated; you do not choose the cloud and you do not run the servers. For some teams managed hosting is exactly the appeal; for others, data residency and control matter, and self-hosting the source is the path to them.

Engine support is the last one. PlayFab is multi-engine, with maintained SDKs for Unity, Unreal Engine 4 and 5, C/C++, C#, and console platforms. Metaplay is Unity-first: the shared-logic model applies only to Unity and C#, and Unreal or custom engines can connect via API but get none of the shared-logic benefit. For an Unreal-primary team, PlayFab provides a native SDK while Metaplay does not.

When each platform fits

Requirement	Platform that provides it
Full source code access and the ability to fork	Metaplay
A turnkey SaaS with zero infrastructure to operate	PlayFab
Unity with shared client/server logic	Metaplay
First-class Unreal or custom-engine support	PlayFab
Native Xbox, PlayStation, and Nintendo auth	PlayFab
Predictable, DAU-based pricing you can forecast	Metaplay
Real-time multiplayer and built-in voice chat	PlayFab
A server-authoritative economy by default	Metaplay
Free backend under an Xbox publishing deal	PlayFab (Foundation Mode)
Deep Azure ecosystem integration	PlayFab
The option to self-host the backend in your own cloud account	Metaplay (Private Cloud)

Migrating to or from each platform

Moving onto Metaplay can be incremental: you migrate systems across one at a time while the rest stays on your current backend, rather than cutting over in a single step. Moving off it means forking the code you already run, since you hold the source.

Moving onto PlayFab uses import tooling for player data and catalogs, while custom server logic is rebuilt as CloudScript or Azure Functions. Moving off it, you export player data through the GDPR export APIs and rebuild your backend logic on the new platform, because the server-side behavior does not come with you.

Frequently asked questions

Can Metaplay be used with Unreal Engine?

Metaplay is Unity-first. An Unreal or custom-engine game can connect over the API, but the shared client/server logic (the feature that lets the same C# run on client and server) requires Unity and C#. For an Unreal-primary game, PlayFab ships a native Unreal SDK; Metaplay's shared-logic model does not extend to Unreal.

How much does PlayFab cost?

PlayFab has a free development tier (up to 1,000 lifetime players per title) and paid tiers at $99/mo (Standard), $1,999/mo (Premium), and $10,000+/mo (Enterprise), each bundling meter credits. On top of the base you pay usage: PlayStream events at $6.60 per million, profile reads at $0.33 and writes at $7.15 per million, and Economy v2 inventory at $3.00 per million reads and $40.00 per million writes. Under Foundation Mode, core services are free for games shipped under an Xbox publishing agreement.

Is PlayFab being deprecated?

No. The platform is alive and Microsoft is still investing in it (Foundation Mode was announced at GDC 2026). The confusion comes from PlayFab Insights Management, which Microsoft deprecated on 11 December 2023 in favor of Azure Data Explorer. The analytics tooling moved; the backend platform did not go away.

Can I self-host PlayFab?

No. PlayFab is a managed service that runs only on Microsoft Azure, so you cannot deploy it into your own cloud or on-prem. The client SDKs are open-source, but the server runtime and Game Manager are closed and operated by Microsoft. Metaplay runs by default on Metaplay Cloud, managed by Metaplay on AWS; because you hold the source, self-hosting in your own AWS account is available through the Private Cloud plan.

Does PlayFab support Unreal Engine?

Yes. PlayFab ships maintained SDKs for Unreal Engine 4 and 5, alongside Unity, C/C++, C#, and console platforms. Metaplay is Unity-first and does not provide a native Unreal SDK.

How do the two platforms compare in production use?

PlayFab launched in 2014, was acquired by Microsoft in 2018, and powers high-profile titles including Minecraft and Sea of Thieves. Metaplay was founded in 2019 by people with backgrounds in the game and software industries and runs live games for studios including Metacore, Trailmix, and Lessmore. Both are production-proven; they suit different team shapes.

Choosing between Metaplay and PlayFab

The two platforms map to different requirements. PlayFab fits teams that want Microsoft to operate the backend, are shipping on consoles or Unreal, or qualify for Foundation Mode under an Xbox deal; it is the older and more turnkey platform with a broad engine and feature surface. Metaplay fits Unity teams that want to own the source, make cheating structurally hard with server-authoritative shared logic, and run an economy-driven live game on Metaplay's managed cloud, with the option to self-host at scale.

To see the shared-logic model and the LiveOps Dashboard running against your own game design, get a demo, or check the pricing page for the live DAU worked example.

For adjacent comparisons, see Metaplay vs Nakama (open-source game server) and Metaplay vs Beamable (C# microservices backend), and the deeper dive on server-authoritative vs client-authoritative architecture.

Pricing and features may change. See Metaplay pricing and PlayFab pricing for current information.