Metaplay vs Unity Gaming Services: Which Game Backend Should You Choose?

If you are choosing a game backend, the Metaplay vs Unity Gaming Services decision comes down to one structural difference: Unity Gaming Services (UGS) is a suite of separate managed cloud services you call from a client SDK and pay for per service, 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. Both are Unity-centric, so this is not a Unity-versus-multi-engine question; it is an integrated source-available server you run versus Unity's pick-the-services-you-need managed suite. This guide walks through architecture, LiveOps, the economy, multiplayer, analytics, and what each one costs.

Metaplay vs Unity Gaming Services at a glance

Category	Metaplay	Unity Gaming Services
Player management	Device, email, social auth; PlayerModel state synced client/server; segment on any player property	Authentication (anonymous, platform, custom) and Cloud Save as separate services; audiences defined from Analytics data
LiveOps	A/B testing, OTA game configs, scheduled live events, player segments, all editable in source	Remote Config, Game Overrides for audience-targeted experiences and A/B testing, Triggers for scheduled server actions
Economy	Server-authoritative currencies and inventory; App Store, Google Play and Steam receipt validation	Economy service for currencies, inventory, virtual and real-money purchases, configured in the dashboard
Multiplayer	Async MMR matchmaker and custom multiplayer entities; no real-time netcode or built-in voice	Relay, Lobby, Matchmaker, Friends, and Vivox voice/text; Multiplay Hosting direct support ended March 2026
Analytics	Built-in tracking and dashboards; stream events to BigQuery or S3	Analytics service with dashboards; free up to 50,000 MAU, billed beyond that
Infrastructure	Metaplay Cloud (managed by Metaplay on AWS); self-host in your own AWS account via Private Cloud	Unity-managed cloud; Unity hosts and operates the services
Operations dashboard	LiveOps Dashboard shipped as Vue source you can extend	Unity Dashboard: managed, closed, configured not extended
Engines	Unity-first (C#, shared logic); Unreal and custom engines via API only	Unity-first; three multiplayer services have an Unreal SDK; other services via SDK or REST
State authority	Server-authoritative by default; deterministic shared logic with checksum validation	Client SDK by default; server authority is opt-in via Cloud Code or your own dedicated servers
AI and developer tooling	Metaplay Agent (public preview) plus Docs and Portal MCP servers; no in-game ML	Safe Voice and Safe Text ML moderation; Game Overrides for experiments; no developer coding-agent equivalent
Pricing	€195/mo Starter; €1,985/mo + €2.95 per 1,000 DAU per day in Production	Pay-as-you-go per service with a free tier each; separate from the Unity editor subscription

What Metaplay and Unity Gaming Services are

Unity Gaming Services is a collection of managed backend services that Unity hosts and operates. Rather than one unified game server, it is a menu you assemble: Authentication, Cloud Save, Cloud Code, Economy, Remote Config, Game Overrides, Leaderboards, Friends, Push Notifications, Analytics, Cloud Content Delivery, the multiplayer stack (Relay, Lobby, Matchmaker, Vivox), and the Safe Voice and Safe Text moderation tools. You wire each one into your game through the Unity SDK and pay for each independently. A team can stand up authentication, cloud saves, and an economy without provisioning a server, and reach for the multiplayer services only when a game needs them.

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 run real live-service games, and both center on Unity. They differ in shape. UGS gives you discrete, individually billed managed services that you compose and that Unity operates. Metaplay gives you one integrated backend, shipped as source you own, server-authoritative by design, and run for you on Metaplay Cloud.

Architecture: shared C# logic vs a suite of managed services

Aspect	Metaplay	Unity Gaming Services
Server language	C# (.NET)	Cloud Code in C# or JavaScript; no full server runtime you host
Client SDKs	Unity (C#); Unreal and custom engines via API	Unity SDK; Unreal SDK for three multiplayer services; REST elsewhere
State authority	Server-authoritative by default	Client SDK by default; server validation is opt-in
Custom server logic	Direct C# in the shared codebase	Cloud Code serverless functions and modules
Hosting	Metaplay Cloud (managed on AWS); self-host via Private Cloud	Unity-managed cloud per service

UGS is built around a client SDK that calls cloud services. By default, your game logic runs on the client and talks to managed endpoints for identity, saves, the economy, config, and the rest. Where you need code the client cannot be trusted to run, you move it into Cloud Code, Unity's serverless compute service. Cloud Code runs C# or JavaScript "in the cloud without managing infrastructure," and Unity positions it to "keep game rules and sensitive data off the client to prevent cheating and reverse-engineering." Its C# modules are generally available.

For real-time dedicated servers you ran your own build on Multiplay Game Server Hosting, though that service has changed (covered in the multiplayer section). Server authority on UGS is available, but it is assembled through Cloud Code or your own dedicated servers rather than the default posture.

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.

That model carries a constraint: 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 is removed (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 the most common economy exploits become structurally impossible rather than something patched after launch. See the Metaplay architecture overview for the full model.

They diverge at where authority lives by default. On UGS each service is authoritative for its own data (the Economy service decides currency balances, Cloud Save holds player blobs), and gameplay rules that span them sit on the client unless you push them into Cloud Code. On Metaplay the whole game model runs server-side from the same deterministic code, so the boundary between "trusted server logic" and "client logic" is drawn once by the architecture rather than per feature by you.

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 (moderation, scoring). The two platforms go opposite ways. Metaplay invests in build-time tooling and ships no in-game ML; UGS ships generally available in-game ML for moderation and offers no developer coding-agent equivalent.

Dimension	Metaplay	Unity Gaming Services
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	No documented coding agent, MCP server, or backend code generation for UGS; Unity's editor and runtime AI (Muse, Sentis) sit outside the gaming-services backend
In-game AI / ML	None built in; matchmaking, segmentation, and experiments are rules- and config-based; analytics stream to your own warehouse for you to model	Safe Voice classifies in-game voice toxicity into a dozen-plus categories; Safe Text moderates chat; both run on Unity's ML models and Safe Voice is engine-agnostic

Metaplay's approach is that 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 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.

UGS approaches ML from the live-game side, focused on player safety. Safe Voice analyzes voice characteristics such as tone, pitch, and context to flag toxic interactions and classify them into more than a dozen categories, and Safe Text does the same for chat with adaptive filtering and player reputation scoring. Both are AI-powered moderation products that integrate with Vivox. Unity also ships editor and runtime AI under Muse and Sentis, but those are creator and inference tools rather than parts of the gaming-services backend. UGS includes in-game ML for moderation; it documents no coding agent for building your backend. 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 Remote Config and Game Overrides

Capability	Metaplay	Unity Gaming Services
A/B testing	Experiments on game-config variants with rollout %, capacity caps, and segment targeting	Game Overrides run experiments and audience-targeted variants across Remote Config, Economy, Matchmaker, and Cloud Content Delivery
Remote config	Game Configs from Google Sheets or CSV, published over-the-air, any data structure	Remote Config namespaced key-value parameters changeable without an app update
Scheduled content	LiveOps timeline with calendar scheduling, recurrence, and UTC or local modes	Game Overrides schedule when and how long an override runs; Triggers fire server actions on a schedule
Player segmentation	Segments on any player property, editable in source	Audiences defined from Analytics data: behavior, location, frequency of play
Dashboard customization	Vue source shipped, add game-specific pages and actions	Unity Dashboard is closed; configure overrides and config, do not extend the UI

This is where the source-vs-managed-suite split is most concrete. UGS gives you Remote Config for key-value parameters you change without shipping a build, and Game Overrides to "target specific player audiences" with configuration changes across several services, using audiences that Unity Analytics groups "by criteria such as behavior, location, and frequency of gameplay." You can run experiments and ship seasonal or veteran-player content to a defined slice of players, with engagement reporting on the result. These capabilities come as managed services rather than something you build.

They diverge in what happens when you need behavior the platform does not offer. 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 can hold any data structure you define, and the LiveOps Dashboard is Vue you can extend with game-specific pages. UGS ships Remote Config and Game Overrides as managed services configured through the Unity Dashboard; Metaplay ships the LiveOps systems as source you can change directly. The flip side of owning the dashboard is owning the work of keeping it current as the SDK evolves.

Player management and authentication

Both platforms cover the standard authentication methods: anonymous device login, platform-specific sign-in, and custom providers, with account linking for cross-platform identity. UGS splits this across services. Authentication handles "anonymous, platform-specific, or custom sign-in," and Cloud Save tracks "player data such as game progress, abilities, and statistics to the cloud, independent of devices." Each is a separate managed service you enable and call, and player segmentation comes from audiences that the Analytics service builds out of telemetry.

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. Rather than reading and writing cloud-save blobs and key-value records from the client, the player's entire state is a server-authoritative object that your shared C# operates on directly. For a game with rich, evolving player state, where an economy, progression, and inventory all interact, the two approaches differ in how state is structured, where authority sits, and whether you compose it from several services or model it as one object.

Economy: server-authoritative by default vs the Economy service

Feature	Metaplay	UGS Economy
Virtual currencies	Multiple types, server-validated via player actions	Currencies for in-game balances, configured in the dashboard
Inventory	Configurable, stored in PlayerModel collections	Inventory items managed by the Economy service
Purchases	Earn, spend, grant through validated player actions	Virtual purchases (currency/items for items) and real-money purchases via a storefront
IAP validation	App Store, Google Play, and Steam, server-side	In-App Purchasing service across supported stores
Transaction authority	Server-authoritative; earn, spend, grant, validate all run server-side	Economy service is authoritative for balances; cross-system rules go through Cloud Code
Source access	Yes; modify any economy behavior	No; the Economy service is managed and configured, not modified

UGS handles the economy through its Economy service, which "manage[s] in-game economy with purchases, currency conversion, and inventory" and lets players "buy in-game currency and inventory items with different in-game currency and inventory items (virtual purchases), or with real money via a digital storefront." You define currencies, items, and purchases in the Unity Dashboard, and the service holds the balances. Logic that has to span the economy and the rest of your game (granting an item as part of a progression step, say) runs in Cloud Code, where you write the server-side validation.

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 in your own C#. The client can show the expected result immediately for responsiveness, but the server determines the real outcome by replaying the same deterministic code. For an economy-driven live game, that means a tampered client cannot grant itself currency, because the grant only counts when the server agrees. Because the economy code is part of your source, you tune its rules directly rather than mapping them onto a managed service's data model.

Multiplayer: async matchmaking vs Relay, Lobby, Matchmaker and Vivox

For real-time multiplayer, UGS provides a dedicated stack of services. Metaplay has no synchronous real-time matchmaker or built-in voice; real-time games integrate a netcode layer such as Photon alongside it. UGS unifies Relay, Lobby, and Matchmaker under a single multiplayer SDK: Relay "securely connect[s] players … without costly dedicated game servers," Lobby lets players "connect before or during the game," and Matchmaker is "a fully featured matchmaking service with low latency." Vivox adds voice and text chat with spatial audio, and Friends adds a social graph. Three of these multiplayer services ship an Unreal SDK, so a non-Unity team can use that slice of UGS.

One change matters for real-time hosting. Unity concluded direct support for Multiplay Game Server Hosting on March 31, 2026 and "licensed [its] Multiplay Game Server Hosting software to Rocket Science Group" to keep live titles running. Dedicated containerized game-server hosting from Unity itself is therefore in transition; teams needing that orchestration now look to Rocket Science Group or another provider. The rest of the multiplayer services (Relay, Lobby, Matchmaker, Vivox, Friends) continue as UGS products.

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, and it has no built-in voice or text chat; those come through integration. That covers turn-based, async-PvP, and economy-driven games. Twitch real-time multiplayer and in-game voice run on UGS's services (with dedicated hosting now via Rocket Science Group) or on a dedicated netcode layer integrated alongside Metaplay.

Analytics: built-in dashboards vs the Analytics service

The two platforms expose analytics differently. UGS offers a dedicated Analytics service that reports player behavior and game performance, and its audiences feed Game Overrides for targeting. Analytics is free up to 50,000 monthly active users and billed beyond that. It is one more service you enable, and the data lives in Unity's platform unless you export it.

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.

Pricing: per-service usage vs DAU tiers

The two pricing models work differently, so a single headline number does not capture the comparison. UGS bills per service against a free tier for each, separate from the Unity editor subscription; Metaplay charges a flat platform fee plus a per-DAU licence billed daily.

Unity Gaming Services pricing

UGS uses a pay-as-you-go model: "you only pay for services beyond the free tier limits." It is not bundled into a Unity editor seat: a Unity Pro subscription is a separate purchase, and UGS has its own billing. You can start most services without a payment method while you stay inside their free tiers, and each service meters independently. Published free-tier examples include:

• Analytics: free up to 50,000 monthly active users
• Relay: 50 average monthly concurrent users (about 2,160,000 connectivity minutes over a 30-day month)
• Vivox: 5,000 peak concurrent users per month on standard pricing
• Cloud Code, Cloud Save, Economy, and Lobby: start free within their tiers, no payment method required

One billing detail affects projects that cross a free tier. Unity states that "if you exceed the free tier limit for any service, your access to all UGS services and APIs is blocked, and you can't make configuration changes," until you add payment details; if you do not within 30 days, the services are disabled for the project. Because each service meters separately, your total is the sum of whatever you use across authentication, saves, the economy, config, multiplayer, voice, analytics, and the rest, and it scales with the specific volumes your design generates. See UGS pricing for current meters and free-tier limits, and Unity's pricing estimator for non-binding estimates.

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: there is no add-on pricing for source access, LiveOps, or the economy, and no per-service metering. 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)
Unity Gaming Services	Sum of per-service usage above each free tier; total swings with the services enabled and the volume each generates

The two models gate on different things, so a clean apples-to-apples number is hard. Metaplay's per-day licence is a function of one figure you already track (DAU), so at high DAU the bill grows but stays forecastable from that single number, and it includes Metaplay hosting and operating the backend with full source. UGS's per-service model can be lower at low volume (much of it starts free) and harder to forecast at scale, because the total is the sum of meters across every service you use and depends on the volumes a given design drives. The two trade a flat, DAU-linked bill against a usage-linked one summed across services. See Metaplay pricing for the live worked example and UGS pricing for current per-service meters.

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, composition, 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. Note that source-available is not the same as OSI open source: Metaplay ships you the code under its own licence. UGS is a set of managed services with client SDKs; you configure and call them but do not get the server runtime as source, so leaving UGS means exporting player data and rebuilding the logic you ran in Cloud Code and across the services elsewhere.

Then there is how the backend is assembled. UGS is composable: you adopt only the services a game needs and pay for each, which suits a team that wants identity and saves now and matchmaking later without taking on a whole platform. Metaplay is integrated: one backend with the LiveOps, economy, and player systems already wired into a single server-authoritative model, which suits a team that wants those systems to share one state and one codebase rather than coordinating several services. Each approach front-loads different work: composition and glue logic on one side, learning a single integrated SDK on the other.

Deployment and data ownership are the third. 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. UGS is Unity-hosted and Unity-operated per service; you do not choose where it runs or self-host it. For some teams managed hosting is the appeal; for others, data residency and control matter, and self-hosting the source is the path to them.

When each platform fits

Requirement	Platform that provides it
Full source code access and the ability to fork	Metaplay
Adopting only the backend services a game needs, billed per service	Unity Gaming Services
Unity with shared client/server logic	Metaplay
Built-in voice and text chat	Unity Gaming Services (Vivox)
ML voice and text moderation in the live game	Unity Gaming Services (Safe Voice / Safe Text)
A server-authoritative economy by default	Metaplay
Real-time multiplayer services (Relay, Lobby, Matchmaker)	Unity Gaming Services
Predictable, DAU-based pricing you can forecast	Metaplay
A free tier on each service to start without payment	Unity Gaming Services
The option to self-host the backend in your own cloud account	Metaplay (Private Cloud)
A build-time AI coding agent for the backend	Metaplay (Metaplay Agent, public preview)

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. Because you hold the source, you can shape the integration to your existing data model. Moving off it means forking the code you already run, or self-hosting via Private Cloud, since the architecture is portable.

Moving onto UGS means enabling the services you need, importing player data into Cloud Save and the economy, and rebuilding server-side rules as Cloud Code. Moving off it, you export player data from each service and rebuild the logic you ran in Cloud Code and across the suite on the new platform, because that behavior does not come with you as source.

Frequently asked questions

Is Unity Gaming Services free?

UGS is pay-as-you-go with a free tier on each service, and it is separate from a Unity editor subscription. You can start most services (Analytics, Cloud Code, Cloud Save, Economy, Relay, Lobby, and Vivox among them) without a payment method while you stay inside their free tiers (for example, Analytics is free up to 50,000 monthly active users). Once you exceed any service's free tier you add payment details, and Unity notes that exceeding a limit blocks access to all UGS services until you do.

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#. UGS is also Unity-first, though three of its multiplayer services (Relay, Lobby, Matchmaker) ship an Unreal SDK and several services are reachable over REST.

Does Unity Gaming Services include dedicated game server hosting?

It did through Multiplay Game Server Hosting, but Unity concluded direct support for that service on March 31, 2026 and licensed the software to Rocket Science Group to keep live titles running. Teams needing dedicated-server orchestration now look to Rocket Science Group or another provider. The other multiplayer services (Relay, Lobby, Matchmaker, Vivox, and Friends) continue as UGS products. Metaplay has no dedicated real-time server either; its matchmaker is async and MMR-based, and real-time games add a netcode layer such as Photon.

How do Metaplay and Unity Gaming Services differ on cheat prevention?

Metaplay's server replays every action from the same deterministic code, so a client lying about its own state is rejected by design, which makes the common economy exploits structurally hard. On UGS, the client SDK is the default and each service is authoritative for its own data; to enforce game rules server-side you move them into Cloud Code, which Unity offers to "keep game rules and sensitive data off the client to prevent cheating." Neither stops every cheat. Bots and automation still need their own detection on either platform.

Can I self-host either platform?

Metaplay Cloud, fully managed by Metaplay on AWS, is the default. Self-hosting on your own AWS account is available through the Private Cloud plan, which provides Terraform modules and Helm charts, typically for studios at very large scale or with specific compliance needs. UGS is a set of Unity-hosted managed services; you do not run them on your own infrastructure.

Does Metaplay have built-in voice chat and moderation?

No. Metaplay has no built-in voice or text chat, and no in-game ML moderation; games that need them integrate a third-party service. UGS provides Vivox for voice and text chat and the Safe Voice and Safe Text ML moderation products. Metaplay's AI investment is build-time tooling instead: the Metaplay Agent (public preview) and the Docs and Portal MCP servers, with analytics streaming to your own warehouse for you to model.

Talk to us about your backend

The two map to different requirements. Unity Gaming Services gives you discrete managed services you compose and pay for individually, with built-in voice and ML moderation and a free tier on each. Metaplay gives you one integrated, server-authoritative backend shipped as source you own and run for you on Metaplay 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 PlayFab (Microsoft Azure backend) and Metaplay vs Nakama (open-source game server), and the deeper dive on server-authoritative vs client-authoritative architecture.

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