Metaplay vs Beamable: A Practical Comparison for Game Developers

Metaplay vs Beamable at a glance

Metaplay and Beamable are both C# game backends for live-service titles, and they take different approaches to ownership. Metaplay ships as full source code and runs by default on Metaplay Cloud, a fully managed service Metaplay operates on AWS, with game logic written once in C# and run on both the Unity client and the .NET server. Beamable is a managed backend-as-a-service on AWS where your custom logic lives in server-authoritative C# microservices, billed against a monthly active user (MAU) cap, and it supports both Unity and Unreal.

Metaplay gives you the source to read and modify every line of your backend, and self-hosting in your own AWS account is available via the Private Cloud plan at scale. Beamable runs as a hosted service with native Unreal support and no infrastructure for you to operate. The rest of this page works through architecture, engine support, pricing, and the differences behind each approach.

Quick comparison table

Category	Metaplay	Beamable
Player management	Device, email, social auth; customizable profiles; segment by any player property	Device, email, social auth; player stats; segment by stats/properties
LiveOps	A/B testing, remote config, live events, OTA config updates; full source access	Trials (A/B), content management, events, announcements; no source access
Economy	Server-authoritative currencies and inventory; server-side IAP validation	Currencies, inventory, stores via server-authoritative C# microservices
Multiplayer	Server-authoritative entities; async MMR matchmaking	Matchmaking, lobbies, relay-based multiplayer
Analytics	Stream events to your own BigQuery or S3	Built-in analytics; Beamable Portal dashboard
Operations	LiveOps Dashboard you can fork and extend (Vue.js)	Beamable Portal; functional, not customizable
Engines	Unity (shared C# logic); Unreal and custom via API only	Unity and Unreal native SDKs; REST for others
Architecture	Server-authoritative; deterministic shared client/server logic	Server-authoritative C# microservices (you write the validation)
AI and developer tooling	Metaplay Agent (public preview) + Docs/Portal MCP servers; no in-product ML	Markets "AI automation"; no documented MCP, assistant, or in-product ML
Pricing	€195/mo Starter; €1,985/mo Production + €2.95 per 1,000 DAU/day	$0 90-day Trial; $125–$3,500+/mo tiers gated by MAU cap

Overview of each platform

Beamable is a backend-as-a-service for live games, built on AWS and managed by Beamable. It exposes authentication, player data, economy, social, and LiveOps through REST APIs, and your custom server logic runs as C# microservices that Beamable hosts. It ships native SDKs for both Unity and Unreal. (In February 2026, Skillz acquired Beamable's technology; confirm current pricing and roadmap with Beamable directly.)

Metaplay was founded in 2019 by people with backgrounds in the game and software industries and ships as source code, hosted by default on Metaplay's managed cloud. Its defining feature is deterministic shared logic: you write your game rules once in C#, and the same code compiles into the Unity client and the .NET server. The server holds authority over all game state, and clients resync on the rare divergence. Studios building on Metaplay include Metacore, Trailmix, and Lessmore.

Both platforms run real live games and cover the full lifecycle of a live-service title. They differ on two main axes: Metaplay provides source ownership and a single shared-logic codebase, hosted by default on its managed cloud; Beamable provides native Unreal support and a fully hosted service it operates for you.

Backend architecture compared

Aspect	Metaplay	Beamable
Server language	C# (.NET)	C# (.NET)
Client SDKs	Unity (C#); Unreal/custom via API	Unity, Unreal, REST APIs
State authority	Server-authoritative, shared deterministic logic	Server-authoritative microservices
Custom logic	Direct C# modification of the SDK source	Beamable Microservices (C#)
Hosting	Metaplay Cloud (managed by Metaplay on AWS); self-host via Private Cloud	Beamable-managed (AWS)
Source access	Full source code	No source access

Beamable: microservices you don't host

Beamable runs a microservices model where game clients call backend APIs, and your custom server logic runs in Beamable Microservices: C# projects that deploy as Docker containers onto Beamable's infrastructure. These microservices are server-authoritative, so the code runs on the server, not the client.

What "validation" means is up to you. Beamable gives you the server-side execution context, but the rules that reject a cheating client are logic you write inside the microservice, not something the framework enforces for you.

The framework auto-generates client code. When you edit a Microservice class, the SDK regenerates a matching MicroserviceClient class for the Unity client (the Unreal SDK can also call microservices). This differs from Metaplay's shared logic: the generated client is a typed API wrapper, not your game rules executing locally. Microservices development requires .NET 8.

Source: Beamable microservices guide

Metaplay: one codebase, server-authoritative

Metaplay compiles your game logic for both Unity (client) and .NET (server). When a player takes an action, it executes locally first for instant feedback, then the server runs the identical code, validates, and persists. If client and server state diverge, the server wins and the client resyncs. Because the same deterministic C# runs on both sides, you don't maintain a separate request/response API surface for core gameplay.

This model requires Unity and C#; engines other than Unity connect over the API without the shared-logic path. For an economy-driven game, the shared-logic model removes a category of client-server sync code and makes client-state tampering structurally ineffective rather than something defended against case by case.

Source: Metaplay architecture documentation

Architecture trade-offs

Consideration	Metaplay	Beamable
Cheat protection	Server replays the same deterministic action; client state tampering rejected by design	Server runs your microservice; you write the validation that rejects bad input
Client-server sync	Automatic via shared logic	You define and call the API surface
Development model	Write game logic once, runs on both sides	Separate game client and server microservices
Infrastructure	Managed by Metaplay on its cloud; self-host with Terraform/Helm via Private Cloud	Beamable runs it
Debugging	Full IDE debugging of the actual server code	Standard microservices debugging on Beamable's runtime

The two cheat-protection models work differently. In Metaplay, the server recomputes the result from the same code, so the common case of a client lying about its own state is rejected by design. In Beamable, the server-authoritative microservice is where validation runs, and that validation is logic you write and maintain. For games where the economy is the product, the two models diverge on whether the framework recomputes state from shared logic or whether you author the rejection rules yourself.

AI and developer tooling

AI appears in two places here. There is AI that assists your team while they build (coding agents, MCP servers, code generation), and AI/ML that runs inside your live game (churn prediction, ML matchmaking, automated moderation). On both, Metaplay publishes specifics and Beamable, as of writing, does not.

Dimension	Metaplay	Beamable
Developer AI tooling	Metaplay Agent (public preview) installs SDK skills for Claude Code, Cursor, and similar tools, plus Docs and Portal MCP servers and the MetaplayGPT docs chatbot	Markets "AI automation built in" alongside its Unity and Unreal SDKs, but publishes no specifics: no documented MCP server, coding assistant, or code generation
In-product AI / ML	None built in; matchmaking, segmentation, and A/B testing are rules- and config-based; analytics stream to your own warehouse	No in-product AI/ML (churn, ML matchmaking, AI moderation) documented

Metaplay's AI work targets developer and operator tooling rather than in-game ML. The Metaplay Agent installs SDK skills so a coding agent works like a Metaplay developer, and the Docs and Portal MCP servers expose documentation, SDK source, and live infrastructure to those tools. Because the source ships with the SDK, an agent reads the actual system it is changing. The Agent is in public preview.

Beamable's marketing mentions "AI automation built in," but at the time of writing it does not document a specific developer AI assistant, MCP server, or in-product ML feature. For AI-assisted development, Metaplay documents the Metaplay Agent (public preview) and the Docs and Portal MCP servers; Beamable documents no equivalent at the time of writing. Its current roadmap can be confirmed with Beamable directly.

LiveOps and content management

Feature	Metaplay	Beamable
A/B testing	Configurable experiments on game config variants	Trials: deploy functionality to player subsets
Events	Live events with phases and scheduling	One-time competitions with phases
Tournaments	Leagues with divisions and seasons	Recurring competitions with stages and tiers
Remote config	Game Configs via Sheets/CSV, published OTA	Content management via Content Manager
Player segmentation	Segments by any player property	Player subset targeting
Dashboard customization	Full source access (Vue.js)	Beamable Portal (not customizable)

Beamable's Events support one-time competitions where players compete over a finite window, and Tournaments add recurring competitions with progression through stages and tiers. Content lives in the Content Manager and publishes to your game.

Metaplay's LiveOps tools cover A/B testing, remote configuration, live events with explicit phases (Preview, Active, EndingSoon, Review), over-the-air config updates, and player segmentation by any player property. The whole LiveOps Dashboard ships as Vue.js source, so dashboard behavior is something you change directly rather than file a request about. Owning the dashboard also means owning the work of keeping it current as the SDK evolves.

Player management and authentication

Feature	Metaplay	Beamable
Device ID auth	Yes	Yes (frictionless guest login)
Email / password	Yes	Yes
Social login	Facebook, Google, Apple, Steam	Facebook, Google, Apple
Steam	Yes	Yes
Console auth (Xbox/PS5/Switch)	Integration required	Federated identity (custom integration)
Epic Online Services	Integration required	Federated identity
Player profiles	Fully customizable PlayerModel	Yes
Cloud saves	Server-authoritative, auto-persisted	Yes (5MB per file)
Cross-platform identity	Yes	Federated identity

Beamable ships native authentication for Facebook, Google, Apple, and Steam; console platforms and Epic Online Services connect through its federated identity layer (OAuth2/OpenID), which you wire up rather than getting out of the box. Metaplay likewise supports console deployment but expects you to wire up the platform-specific auth flows yourself.

Source: Beamable documentation

Game economy systems

Feature	Metaplay	Beamable
Virtual currencies	Multiple types via MetaRewards	Soft (earned) and hard (purchased) currencies
Inventory	Fully customizable PlayerModel collections	Managed via InventoryService
Stores	Offers, offer groups, segment targeting	Commerce with virtual and real currency
IAP validation	Server-side: App Store, Google Play, Steam	Multiple platforms
Transaction authority	Server-authoritative (shared logic)	Server-authoritative microservice
Source access	Yes	No

Beamable's economy covers inventory through the InventoryService, stores for commerce, and soft/hard currencies. Items are created in the Content Manager and granted through gameplay or store purchases, with the transaction running server-side in a microservice.

Metaplay's economy is server-authoritative through the same shared-logic path as the rest of the game. The client can show an expected result for responsiveness, but the server recomputes and decides the final state. Because the currency and inventory code is part of your source, you tune the rules directly rather than mapping them onto a managed service's model.

Social and multiplayer features

Feature	Metaplay	Beamable
Chat	Integration required	Built-in (Chat V2)
Guilds / groups	Guild framework with roles	Parties and guilds
Friends	Yes	Yes
Leaderboards	Leagues system, sharded divisions	Global and segmented
Matchmaking	Async MMR matchmaker	Yes
Lobbies	Via multiplayer entities	Yes

Beamable includes built-in chat through Chat V2, so teams get in-game communication without adding a third-party service. Metaplay has no built-in chat and expects you to integrate one. For games where real-time chat is a core requirement, Beamable provides it natively and Metaplay does not.

On matchmaking, the two platforms target different shapes of game. Metaplay's matchmaker is async and MMR-bucket based, built for asynchronous PvP and progression matchups rather than real-time netcode. Beamable offers matchmaking plus relay-based multiplayer. Neither is a physics-authoritative real-time server for twitch shooters, and both expect you to bring that layer if you need it.

Engine and platform support

Aspect	Metaplay	Beamable
Unity	Full support, shared C# logic	Native SDK
Unreal	API access only (no native SDK)	Native SDK with Blueprint support
Custom engines	API access	REST APIs
Console (Xbox/PS5/Switch)	Deployment supported; auth integration required	Deployment supported; auth via federated identity
Shared client/server logic	Yes (Unity/C#)	No

Engine support is a structural difference between the two. Beamable ships an Unreal SDK with Blueprint-compatible nodes, editor support for realms (dev/staging/prod), and UE Python integration for content work, and it supports Windows, mobile, console, Steam, and Epic Online Services. Metaplay is Unity-first by design: its shared-logic model depends on the same C# running on client and server, so Unreal and custom engines can connect over the API but get none of the shared-logic benefit. For an Unreal client, the two differ on whether the SDK is native (Beamable) or API-only (Metaplay).

Source: Beamable documentation

Pricing compared

Beamable pricing

Beamable's tiers are gated primarily by a monthly active user (MAU) cap and the number of microservices, with overage charged on API calls above the included volume.

Tier	Price	MAU cap	Microservices	Notes
Trial	$0 (90 days)	1,000	3	Time-limited evaluation
Developer	$125/month	1,000	3	Entry paid tier
Studio	$595/month	30,000	10
Pro	$1,895/month	100,000	25
Enterprise	$3,500+/month	Unlimited	75	Custom

Overage runs $100 per 10 million API calls, and extra microservices are $20/month each beyond the tier's included count. Beamable also offers LaunchPad: $2,500 in onboarding and license credits, applicable to its Unity and Unreal offerings.

Source: Beamable pricing

Metaplay pricing

Metaplay uses flat monthly tiers, with the Production tier adding a daily DAU licence fee on top of the base.

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

The DAU fee is charged per day and accumulates across the month, so it scales with how busy your game actually is. Worked example from Metaplay's pricing page: a game at 100,000 DAU every day in a 30-day month bills on 95,000 DAU/day after the 5,000 included, which is 95,000 ÷ 1,000 × €2.95 = €280.25/day, or €8,407.50 across the month, for €10,392.50/month total including the €1,985 base. Every feature is included in every paid tier. See Metaplay pricing for the live numbers and worked example.

Put that €10,392.50/month at 100,000 DAU in context: it is roughly 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 an in-house backend build at around $21M over a typical multi-year build: The true cost of building your own backend.

Cost comparison

The two models gate on different things, so a clean apples-to-apples number is hard; the binding constraint differs on each side. On Beamable, tiers are capped by MAU, not API calls. A game with 50,000 daily active users will run past the Studio tier's 30,000 MAU cap over a month, so the relevant plan is Pro at $1,895/month (its 100,000 MAU cap covers 50,000 DAU), before any microservice or API overage.

On Metaplay, the same 50,000 DAU sustained every day works out to a per-day model:

Component	Calculation	Monthly
Base (Production)	flat	€1,985.00
DAU licence	(50,000 − 5,000) ÷ 1,000 × €2.95 × 30 days	€3,982.50
Total		€5,967.50/month

So at 50,000 sustained DAU, Beamable's Pro tier (~$1,895/month before overage) comes in lower on the headline subscription, while Metaplay's per-day licence makes it the larger monthly bill at that scale. The two figures cover different things: Metaplay's includes Metaplay hosting and operating the backend, with full source, and the DAU model tracks daily activity rather than a fixed MAU ceiling. At low MAU and light usage, Beamable's $125 Developer tier (or the 90-day free Trial) is cheaper to start; once you cross its MAU caps, you step up tiers. Because both pricing pages change, treat these as worked illustrations and confirm against Metaplay pricing and Beamable pricing.

Key differences

Source code access and lock-in

Aspect	Metaplay	Beamable
Source code provided	Yes	No
Modify core behavior	Yes, directly in the source	Via microservices around the platform
Take it with you if you leave	Fork the source	No code to take

Metaplay includes full source for the C# server, Unity SDK, and the Vue.js dashboard in every paid tier, so you read, modify, debug, and extend any part of it, and you can fork it if you ever leave. Beamable does not provide source; you customize by writing microservices that run on its platform, and migrating off means exporting player data and rebuilding your logic elsewhere. Note that "source-available" is not the same as OSI open source: Metaplay ships you the code under its own licence, not an open-source one.

Engine support and Unreal

Aspect	Metaplay	Beamable
Unity	Full support (shared logic)	Native SDK
Unreal	API access only	Native SDK with Blueprints
Console platforms	Integration required	Federated identity

For Unreal projects, Beamable has a native SDK with Blueprint support, while Metaplay's shared-logic architecture depends on C# running on both client and server and exposes only an API to non-Unity engines.

Infrastructure and data ownership

Aspect	Metaplay	Beamable
Infrastructure location	Metaplay Cloud (managed on AWS); self-host via Private Cloud	Beamable-managed (AWS)
Data ownership	You own the data and can export it; full source ships with the SDK	Data sits on Beamable's infrastructure
Operated by	Metaplay (managed); self-operate with Terraform/Helm via Private Cloud	Beamable

When each platform fits

Capability or need	Where it's found
Full source code and no lock-in	Metaplay
A hosted service with no infrastructure to run	Beamable
Unity with shared client/server logic	Metaplay
A native Unreal SDK with Blueprints	Beamable
Built-in chat	Beamable
DAU-based pricing that tracks daily activity	Metaplay
A low entry price and an MAU-capped ladder	Beamable
Server-authoritative economy through shared logic	Metaplay
A 90-day free trial to evaluate	Beamable

Migrating between the platforms

Moving to Metaplay

Metaplay supports incremental migration: you can move systems across one at a time while the rest of your game stays on its current backend. Because you get the source, you can shape the integration to your existing data model.

Leaving Metaplay

You hold the source and the architecture is portable, so there is no platform to be locked out of: self-host via Private Cloud or fork the code and keep going.

Moving to Beamable

Beamable's model means re-implementing server logic as C# microservices on its platform, and player data comes across by export and import.

Leaving Beamable

There is no source code to take with you. You export player data and rebuild your backend logic on whatever you move to.

FAQ

Is Beamable cheaper than Metaplay?

It depends on scale. At a low monthly active user count, Beamable is cheaper to start: its Developer tier is $125/month and it has a 90-day free Trial, while Metaplay's Production tier starts at €1,985/month. As your audience grows you climb Beamable's MAU-capped ladder (Studio $595, Pro $1,895, Enterprise $3,500+), and Metaplay's per-day DAU licence accumulates with activity.

At, say, 50,000 sustained DAU, Beamable's headline subscription (Pro, ~$1,895/month before overage) is lower than Metaplay's ~€5,967.50/month, and Metaplay's figure includes Metaplay hosting and operating the backend, with full source. Compare on your real numbers via Metaplay pricing and Beamable pricing.

Does Beamable support Unity?

Yes. Beamable ships a native Unity SDK, and its microservices framework auto-generates a typed client for Unity. It also supports Unreal natively. Metaplay is Unity-first as well; on Metaplay your game logic runs as shared C# on both the Unity client and the server.

Can I migrate from Beamable to Metaplay?

Yes, incrementally. Beamable doesn't give you source code, so you re-implement your server logic as shared C# in Metaplay and bring player data across by export and import. Metaplay's incremental migration lets you move one system at a time rather than rebuilding everything at once. Since Metaplay ships as source, you can tailor the migration to your existing data.

Can Metaplay be used with Unreal Engine?

Metaplay is designed for Unity. An Unreal or custom-engine client can connect over the API, but the shared client/server logic that lets the same C# run on both sides requires Unity and C#. For an Unreal client, Beamable provides a native Unreal SDK with Blueprint support, while Metaplay provides API access without the shared-logic path.

Which platform is better for cheat prevention?

Metaplay's server-authoritative shared logic recomputes every action on the server from the same deterministic code, so a client lying about its own state is rejected by design. Beamable's microservices are also server-authoritative, but the validation that catches bad input is logic you write inside each microservice. Note that no backend 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, not GCP or Azure) 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. Beamable is a managed SaaS on AWS, so you don't run your own infrastructure.

Does Beamable support dedicated game servers?

Beamable's documentation describes matchmaking and turn-based multiplayer "without the need to build, run, and scale a game server." For real-time, physics-authoritative multiplayer you'll likely add a dedicated-server layer on top; the same is true of Metaplay, whose matchmaker is async and MMR-based rather than real-time netcode.

Talk to us about your backend

If you're weighing Metaplay against Beamable for a specific game, you can walk through your architecture with us. Get a demo to discuss where Metaplay fits your project and where it doesn't.

See also Metaplay pricing, and our other head-to-head comparisons: Metaplay vs PlayFab and Metaplay vs Nakama.