How Metaplay, PlayFab, Nakama, Beamable, and Unity Gaming Services compare for F2P mobile games: economy integrity, LiveOps speed, IAP validation, and cost at scale.
The five backends at a glance
Three questions decide the backend for a free-to-play mobile game: can it stop players cheating your economy, can it run live events and A/B tests without an app update, and can you predict the bill as DAU grows. Metaplay uses server-authoritative, shared client/server logic written in C# for Unity, which makes economy cheating structurally hard rather than something you patch after the fact. PlayFab offers broad service coverage and a free development tier, with native Microsoft and Xbox integration. Nakama is an open-source server you can self-host and own outright. Beamable runs managed microservices for Unity and Unreal teams. Unity Gaming Services (UGS) wires its services into the Unity editor for Unity-only teams.
Below is how each platform handles those three questions, the numbers, and the constraints of each.
| Category | Metaplay | PlayFab | Nakama | Beamable | UGS |
|---|---|---|---|---|---|
| Economy authority | Server-authoritative by default; deterministic shared logic | Server validation, opt-in via CloudScript/Functions | Authoritative via custom match handlers | Server-authoritative C# microservices | Server-authoritative via Cloud Code (opt-in) |
| LiveOps | A/B tests, events, segments, OTA configs; dashboard source included | Experiments, Title Data, Scheduled Tasks | Satori (separate product) | Trials, events, remote config | Remote Config, Game Overrides |
| IAP validation | App Store, Google Play, Steam; server-side | Apple, Google, Amazon, Windows | Apple, Google, Huawei | Server-side receipts | Unity IAP receipt validation |
| Cheat prevention | Architectural; client can't author state | Detection + server validation | Authoritative matches available | Server validates state changes | Cloud Code as authority |
| Engine support | Unity-first (API access for others) | Unity, Unreal, custom, consoles | Unity, Unreal, Godot, Defold | Unity, Unreal | Unity only |
| AI tooling | Metaplay Agent + Docs/Portal MCP; no in-product ML | Copilot (preview, GDC 2024); churn ML + AI moderation | Satori + Databricks ML; community MCP | "AI automation" (no published specifics) | Unity AI (editor) + Safe Text/Voice ML |
| Source code | Full source access | Client SDKs OSS; server closed | Apache-2.0, fully open | Closed | Closed |
| Pricing | €1,985/mo + €2.95/1k DAU/day (Production) | Free dev tier; usage-based | Free self-host; Cloud from ~$600/mo | $125–$1,895/mo by MAU tier | Free tier; usage-based per service |
What a free-to-play mobile game actually needs
Three backend properties move revenue on a free-to-play mobile title.
Economy integrity. Mobile is a hostile cheating environment. Memory editors, rooted devices, and repackaged APKs are a download away, and a F2P economy is a common target. Infinite currency undermines monetization.
The durable defense is a server that holds authority over every currency and inventory change: the client requests an action, the server validates and executes it, and a tampered local state buys the cheater nothing. How each platform gets there differs, and that difference is the spine of this comparison.
LiveOps speed. A live F2P game changes its economy, offers, and event calendar weekly, often daily. Retuning drop rates, pushing a limited-time event, and A/B testing a price without shipping a client build through store review are common requirements. On some backends that is a config publish; on others it is an engineering task, and the gap compounds across a game's lifetime.
IAP validation. Receipt validation for the App Store and Google Play has to handle sandbox versus production, lost network round-trips, subscription renewals, and refund fraud. Errors can grant items for fake purchases or fail real ones, with revenue consequences either way. Every platform here does server-side validation. They diverge at how much of the edge-case handling you inherit versus write yourself.
Economy and cheat prevention
This section is where the platforms differ most.
Metaplay's model works like this. Game logic is written once in C# and compiled into both the Unity client and the .NET server. The same code runs in both places, the server is authoritative, and a deterministic checksum catches any divergence. A currency spend or inventory grant executes locally for instant UI feedback, then the server confirms and resyncs on a mismatch.
A player editing memory can change what they see, but the server recomputes the real state from validated actions, so the cheat does not land. The cost of this model: a portion of the game logic has to stay deterministic and compile to both targets, which is a constraint teams have to learn. The trade-off is that a class of exploits becomes impossible by construction rather than something detected after the damage.
PlayFab takes the managed-service route. Its Economy v2 reached general availability in 2023 and runs Minecraft's economy at Microsoft scale. Inventories hold up to 10,000 items per collection, catalogs scale to 20GB, and Redeem APIs are idempotent to prevent double-charging.
Server authority is opt-in. By default many operations are client-initiated with server validation, and you tighten it by moving sensitive logic into CloudScript (Azure Functions) and restricting client APIs through Access Policies. That is more setup than Metaplay's default-on authority, and it comes with established fraud tooling such as the idempotent Redeem APIs.
Nakama provides the primitives and expects you to assemble the economy. The open-source server ships storage, wallets, and authoritative match handlers, but a full economy comes from Hiro, Heroic Labs' separately-licensed metagame toolkit (currencies, inventory, stores, achievements). Cheat prevention is as strong as the validation logic you write in Go, TypeScript, or Lua. The model gives full control and the corresponding implementation responsibility.
Beamable runs server-authoritative C# microservices on AWS that auto-generate a client SDK. State changes go through your microservices, which validate them server-side. This is server authority, with one difference from Metaplay: Beamable generates a client interface to your services rather than sharing deterministic game logic across client and server, so you still write and maintain the validation yourself.
UGS reaches authority through Cloud Code, serverless C# or JavaScript that runs as the source of truth, with server time to defeat clock manipulation. Unity Economy handles currencies and inventory for simpler games, with fewer features than the dedicated economy systems above, and Unity's own docs point to third-party anti-cheat for client protection.
| Economy capability | Metaplay | PlayFab | Nakama + Hiro | Beamable | UGS |
|---|---|---|---|---|---|
| Default server authority | Yes, architectural | Opt-in (CloudScript) | Via match handlers | Yes (microservices) | Opt-in (Cloud Code) |
| Shared deterministic client/server logic | Yes | No | No | No | No |
| Currencies + inventory | Server-authoritative | Economy v2, up to 10,000 items/collection | Hiro wallets + inventory | Soft/hard currency, custom stats | Economy service |
| State validation | Automatic via checksum | Manual, per transaction | Manual, in runtime code | Manual, in microservices | Manual, in Cloud Code |
| IAP receipt validation | App Store, Google Play, Steam | Apple, Google, Amazon, Windows | Apple, Google, Huawei | Server-side receipts | Unity IAP |
| Fraud handling inherited | High | High (idempotent Redeem APIs) | You build it | Moderate | Moderate |
In summary: Metaplay makes economy cheating structurally hard and requires the least validation code to write, with a determinism constraint and Unity-first development. PlayFab covers a broad service range and adds native console reach, and server authority is configured rather than default. Nakama, Beamable, and UGS enforce server authority once you write the server-side validation.
LiveOps tooling compared
Every platform here can change live content without an app update; what differs is how much is built in versus bolted on, and whether you can see the source.
Metaplay ships the LiveOps Dashboard in every paid tier, and its source is included so you can add game-specific pages and actions. Experiments run A/B tests on player audiences with rollout percentages and full per-player history; segments, live events, and game configs (edited in Google Sheets or CSV, published over the air) complete the set.
PlayFab's Experiments run up to 9 variants, with statistical-significance analysis and Sample Ratio Mismatch detection, powered by the same internal platform Microsoft uses for Minecraft and Bing. Its Title Data plus Scheduled Tasks (5-minute cron granularity) cover remote config and timed content.
For Nakama, LiveOps is a separate product: Satori (from $600/month, billed independently of Nakama) provides experiments, feature flags, audiences, live events, and metrics. Beamable bundles A/B testing via segmentation, remote config, multi-phase competitive events, broadcasts, and player mail. UGS covers Remote Config with targeting rules and Game Overrides for A/B tests; it does not include the statistical-significance analysis that PlayFab and Metaplay provide, and there is no source access to the dashboard.
| LiveOps feature | Metaplay | PlayFab | Nakama + Satori | Beamable | UGS |
|---|---|---|---|---|---|
| A/B testing | Audiences + rollout %, full history | Experiments, up to 9 variants | Satori experiments | Via segmentation | Game Overrides (basic) |
| Statistical analysis | Built-in | Significance + SRM detection | Satori goal metrics | Limited | Limited |
| Remote config / OTA | Game configs via Sheets/CSV | Title Data | Satori feature flags | Remote config | Remote Config + CCD |
| Player segmentation | By any player property | PlayStream segments | Satori audiences | By stats/properties | Analytics audiences |
| Live events scheduling | Phased events, UTC/local | Scheduled Tasks (cron) | Satori live events (cron) | Multi-phase events | Limited |
| Dashboard source access | Yes (Vue.js) | No | No | No | No |
On LiveOps tooling, Metaplay includes the dashboard source so you can extend it, and PlayFab's experimentation stack runs up to 9 variants with statistical-significance analysis. Nakama's LiveOps lives in a second product (Satori) that you license and pay for separately.
AI tooling and in-product AI
AI appears in two distinct places: tooling that helps your team build the game (assistants, MCP servers, code generation) and in-product AI/ML that runs in the live game (churn prediction, ML matchmaking, moderation). For F2P mobile, in-product moderation and churn models matter operationally, while developer AI tooling affects how fast you ship.
| Platform | Developer AI tooling | In-product AI / ML |
|---|---|---|
| Metaplay | Metaplay Agent (public preview) installs SDK skills for Claude Code and Cursor, plus Docs and Portal MCP servers and the MetaplayGPT docs chatbot | None built in; matchmaking, segmentation, and A/B testing are rules-based; analytics stream to your own warehouse |
| PlayFab | PlayFab Copilot in Game Manager (Private Preview, GDC 2024) | Churn Prediction (Azure ML) feeding segmentation; Party speech-to-text and translation; text moderation via Azure AI Content Safety |
| Nakama | Docs written for LLMs; no official MCP or assistant (community MCP is third-party) | Satori + Databricks ML (churn, LTV, engagement) and GenAI analytics |
| Beamable | Markets "AI automation built in" with no published specifics | None documented |
| UGS | Unity AI in-editor assistant (open beta, Unity 6.2) and official Unity MCP server (engine and editor, not a UGS backend assistant) | Safe Text and Safe Voice ML moderation (with Vivox) |
Metaplay's AI is in developer tooling: a shipped agent and MCP servers that read source you own. PlayFab and UGS provide in-product safety and churn ML through their cloud stacks: Metaplay's AI is aimed at engineering, while PlayFab and UGS add built-in moderation and churn models. Beamable publishes no specifics in either column; confirm its current AI roadmap with the vendor directly.
What it costs at scale
Pricing models differ enough that a single "monthly cost" column would mislead. Metaplay charges a base fee plus a per-day DAU licence, PlayFab and UGS bill metered usage, Nakama bills compute, and Beamable gates on monthly active users. Here is each one in its own terms, with a worked Metaplay figure you can verify.
Metaplay: base fee plus a per-day DAU licence
Metaplay's Production plan is €1,985/month plus a licence fee of €2.95 per 1,000 DAU, charged per day, with the first 5,000 DAU each day included. The licence is charged per day, multiplied across the month. Using Metaplay's own worked example: a game with 100,000 DAU every day in a 30-day month bills (100,000 − 5,000) ÷ 1,000 × €2.95 = €280.25/day, then × 30 = €8,407.50, for a total of €10,392.50/month including the base fee.
For context, €10,392.50/month is roughly the fully loaded cost of one 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 analysis puts an in-house backend build at around $21M over a typical multi-year build: The true cost of building your own backend.
Applying the same formula across DAU levels:
| Sustained daily DAU | Daily licence fee | Monthly licence (× 30) | Total incl. €1,985 base |
|---|---|---|---|
| 50,000 | €132.75 | €3,982.50 | €5,967.50/mo |
| 100,000 | €280.25 | €8,407.50 | €10,392.50/mo |
| 500,000 | €1,460.25 | €43,807.50 | €45,792.50/mo |
Below Production the ladder covers earlier stages: Free (€0, local development with the full SDK), Starter (€195/month, 1 mini environment, capped at 5 DAU), and Pre-Launch (€995/month, 2 small environments, capped at 100 DAU). Above Production, the Private Cloud (Enterprise) plan self-hosts in your own AWS and drops the licence to €2 per 1,000 DAU, an option studios above ~1M DAU use to reduce the bill. Every feature is included at every paid tier; you pay for scale, not to switch features on.
The others
- PlayFab is usage-metered. Standard is $99/month with $400 of included meter credits; Premium is $1,999/month with $8,000 of credits. The meters relevant to a F2P economy are PlayStream events ($6.60/M), profile reads ($0.33/M) and writes ($7.15/M), and Economy v2 inventory reads ($3.00/M) and writes ($40.00/M). Cost varies with the volume of inventory operations; a write-heavy economy raises the bill. Foundation Mode (announced GDC 2026) makes core PlayFab services free for games shipped under an Xbox publishing agreement, which can take the backend bill to zero for qualifying titles.
- Nakama (Heroic Cloud) is compute-based, from roughly $600/month (now quoted via a calculator, so treat that as a floor) with no DAU/MAU/CCU caps, and includes the Nakama Enterprise license. Add Satori for LiveOps from another $600/month. Support is a separate line: Studio Basic $2,000/month, Studio Standard $6,000/month (24/7, 8-hour response, 99.5% SLA), Premium custom. Self-hosting the open-source server is free if you have the DevOps capacity.
- Beamable gates on monthly active users, not API calls. Tiers run Developer $125/month (1,000 MAU), Studio $595/month (30,000 MAU), Pro $1,895/month (100,000 MAU), and Enterprise $3,500+/month (unlimited), with API overage at $100 per 10M calls and extra microservices at $20/month each. The binding constraint as you grow is the MAU cap on your tier.
- UGS has a free tier and bills usage per service (Cloud Code, Economy, Remote Config, etc.) above each service's included allocation. There is no single subscription that "includes" UGS; it is consumed à la carte, so cost depends entirely on which services you use and how heavily.
A note on a common misconception: UGS is sometimes folded into a Unity Pro editor seat (around $2,310/year). They are unrelated: the editor seat is a development licence, while UGS backend services are billed separately on usage. The two are budgeted separately.
The pattern across all five: usage- and compute-metered models (PlayFab, Nakama, UGS) vary more with scale, while Metaplay's and Beamable's flatter structures trade some of that variance for a more forecastable bill. The fit depends on how spiky your traffic is and the relative weight placed on billing certainty versus a possibly-lower variable bill.
Which one to pick
| If you need... | Consider |
|---|---|
| Default server-authoritative economy with the least validation code | Metaplay |
| Shared deterministic client/server game logic | Metaplay |
| Full source code access | Metaplay, Nakama (open source) |
| Turnkey managed SaaS, no infrastructure to run | Metaplay, PlayFab, Beamable, UGS |
| Native Xbox/PlayStation/Nintendo auth | PlayFab |
| Open-source server you self-host and own | Nakama |
| Tight Unity-editor integration | UGS, Beamable |
| Statistical-significance A/B testing | PlayFab, Metaplay |
| A forecastable bill as DAU climbs | Metaplay, Beamable |
| Lowest entry cost for a prototype | PlayFab (free dev tier), UGS (free tier), Nakama (self-host) |
For more detail on economy integrity and LiveOps across these platforms, the head-to-head comparisons go deeper on architecture, migration, and pricing than a roundup can: Metaplay vs PlayFab, Metaplay vs Nakama, and Metaplay vs Beamable.
To talk through your specific game, book a demo and we'll walk through your economy model, expected DAU, and where Metaplay does and doesn't fit, including the cases where another platform matches your needs.
FAQ
What is the best backend for a free-to-play mobile game?
It depends on the game and team. For an economy-driven F2P mobile game built in Unity, Metaplay's server-authoritative architecture and shared client/server logic make economy cheating structurally hard, and full LiveOps tooling ships in every tier. For teams tied to Xbox or the Microsoft ecosystem, PlayFab provides native console integration and a free development tier. For an open-source server you own outright, Nakama is Apache-2.0 and self-hostable. Beamable and UGS run as managed services with tight Unity integration.
What's the best backend for a hypercasual mobile game?
A hypercasual game has shallow systems and tight margins, so a lighter setup covers its needs. UGS (for teams already in Unity) and PlayFab's free development tier cover analytics, remote config, and IAP without much engineering, and the free tiers cover a launch. A server-authoritative platform adds capability that a hypercasual title with no economy may not use; that calculus changes if the title starts monetizing more heavily.
What's the cheapest backend for a mobile game?
At zero scale, self-hosting open-source Nakama (Apache-2.0) is free apart from your own hosting, and both PlayFab and UGS have free tiers that cover a launch. The lowest-cost option changes as you grow: PlayFab's metered bill can stay low for a read-light game, Beamable's entry tier is $125/month, and PlayFab Foundation Mode is free entirely for games under an Xbox publishing agreement. Modeling your real DAU and usage shows the cost at scale, which can differ from the headline sticker price.
Do I need a server-authoritative backend for a single-player F2P game?
Yes, if it has an economy or IAPs. "Single-player" doesn't mean cheat-free: a player editing local memory or a save file can grant themselves currency and items, and if those drive purchases or leaderboards, that affects revenue and ranking integrity. A server-authoritative economy stops it at the source. If the game has no economy, no purchases, and no competitive ranking, a lighter backend is sufficient.
Which platform provides the strongest cheat prevention for economy systems?
The platforms reach cheat prevention differently. In Metaplay, authority is architectural rather than configured: game logic runs deterministically on both client and server, the server holds the real state, and a checksum catches divergence automatically. PlayFab, Nakama, Beamable, and UGS each enforce server authority through validation you implement per transaction: in CloudScript, runtime code, microservices, or Cloud Code respectively.
Can I use Nakama without Hiro or Satori?
Yes. Nakama is open source and runs standalone for auth, storage, multiplayer, and leaderboards. You only add Hiro (economy and progression) or Satori (LiveOps) when you want those systems prebuilt rather than written yourself, and both are licensed and billed separately from Nakama.
Do these platforms support subscription IAPs?
Metaplay and PlayFab have built-in subscription handling, including renewal notifications. Nakama validates subscriptions via its IAP layer. Beamable and UGS support purchases but rely more on custom implementation for subscription lifecycle edge cases; confirm the specifics against your store requirements.
Which platform is best for cross-platform mobile-plus-console games?
PlayFab has the broadest native console authentication (Xbox, PlayStation, Nintendo) and SDKs for console platforms. Beamable connects console sign-in through federated identity (OAuth2/OIDC) you wire up, not native providers. Metaplay supports console deployment but handles platform-specific auth through custom integration, and Nakama and UGS need custom work for console platform services.
Can I migrate between these platforms after launch?
Migration is possible but means exporting data, mapping schemas, and updating the client. Platforms with full source access (Metaplay, Nakama) give more control over the process because you can read and adapt the system you are moving from rather than working against a closed API. The data export path is worth planning before launch.
