Frequently asked questions

Metaplay is the only backend purpose-built for every stage of game production—from development to liveops and player support. It ships as source code in your own cloud, giving you full control and the security/flexibility of an in-house backend without building it yourself.

The power of the Metaplay SDK lies in its adaptability, flexibility, and extensibility. Metaplay is the ideal solution for making any kind of game, as long as you've got aspirations to take it to the top.

You can use Metaplay to make anything ranging from single-player games with server-side persisted state and cheat-proof game logic, to games with deep meta or social features like guilds and live events. Metaplay's server-authoritative backend also makes it an ideal solution for real-time games like builders with RTS battles, card games, and arena brawlers.

Whether you're making a merge game, a match-3 game, another type of puzzle game, a build-and-battle game, or anything in between, Metaplay has everything you need to build something incredible.

Metaplay has been used by studios building top-grossing mobile games since 2019. We've been working with select partners to build and refine the platform, focusing on quality over quantity.

Metaplay is designed for studios that want source access and first-class programmability—not a black box backend. It's ideal for teams building server-authoritative games of any genre, from prototype to global launch, and for organizations operating multiple titles that need shared tooling and reliable LiveOps.

If you're building a game with aspirations to reach the top, Metaplay provides the infrastructure and tools you need to get there.

We understand that many game developers are hesitant to use a third-party backend. That's why we've done everything we can to remove vendor risk, and ensure you feel comfortable making and running games with Metaplay not just now, but in the future too.

Crucially, Metaplay ships as source code deployed into your own cloud. That means that you'll always be in full control of your game and your data, and should anything ever happen to Metaplay, your game will keep on running.

So, while it might be risky to run your game off other third-party backends, you can rest assured that that's not the case with Metaplay. Making games with Metaplay is just as reliable as using an in-house backend, but with all the added benefits of having pre-made features, tools, structures and workflows that help you ship better, faster.

Metaplay is built on C# and .NET, with first-class Unity integration. The SDK includes a Unity client library and a .NET-based game server that runs on your own cloud infrastructure.

The shared C# codebase between client and server enables powerful features like client-side prediction, offline play, and cheat-proof game logic - all while keeping your code DRY and maintainable.

Yes! Metaplay is designed for incremental adoption. You can integrate LiveOps features (configs, segmentation, A/B testing) without refactoring your core game logic. For existing Unity projects, we provide migration guides and best practices.

Many studios start with cloud saves and LiveOps features, then gradually adopt more capabilities. The Trash Dash tutorial demonstrates integrating Metaplay into an existing endless runner game with minimal refactoring.

Metaplay supports Unity games on iOS, Android, PC (Windows/Mac/Linux), and WebGL. The backend runs on any cloud provider (AWS, GCP, Azure) and can be deployed to any Kubernetes cluster.

The Unity SDK works with Unity 2020.3 LTS and later versions.

For a new Unity project, you can have basic player state syncing working in a few hours. Full integration with LiveOps features typically takes 1-2 weeks for a small team.

For existing games, integration time varies based on how much you want to adopt initially—starting with just cloud saves and configs can be done in days.

No. Metaplay is designed for incremental adoption. You can start by adding cloud saves and LiveOps features to an existing game without rewriting core gameplay.

The shared code model means you write game logic once and it runs on both client and server, but you can adopt this gradually as you add new features or refactor existing ones.

If you're familiar with C# and Unity, the core concepts (Models, Actions, Game Configs) are straightforward. The SDK includes sample projects (HelloWorld, Idler, Orca) and tutorials (Wordle, Trash Dash) to accelerate learning.

Most developers are productive within a week. The LiveOps Dashboard requires minimal setup and works out of the box.

Metaplay is the only backend that ships as source code deployed to your own cloud, giving you full control and eliminating vendor lock-in. Unlike black-box solutions, Metaplay is fully programmable—you can extend, customize, or replace any component.

It's purpose-built for top-grossing live-service games with battle-tested infrastructure that scales to millions of players. You get the security, flexibility, and control of a custom in-house backend without having to build or manage it yourself.

Yes. Metaplay ships as source code and can be deployed to your own infrastructure. You can use our managed cloud hosting, self-host on AWS/GCP/Azure, or run it on-premises.

Many large studios self-host for full control and cost optimization. The infrastructure is Kubernetes-based and well-documented.

Metaplay consists of:

• A Unity client library packed with features to make game programming smoother, like shared client-server logic, workflow tooling, client prediction, offline development, and more.
• A robust and scalable backend that's designed especially for the demands of top-tier games.
• A devops environment with configurations and tooling to provision and manage cloud deployments. And you don't even need to look under the hood (unless you want to, of course).
• A first-of-its-kind liveops dashboard for managing multiple areas of your game in one place, such as configuration and player support. Use it to segment your players and run A/B tests, define economies and ship over-the-air updates, and much, much more.

Additionally, the Metaplay SDK ships with ready-made solutions ranging from localization to matchmaking, leagues and leaderboards, content delivery and guilds, and everything in between.

Metaplay includes a comprehensive LiveOps dashboard with features for:

• Player segmentation - Target specific player groups with tailored experiences
• A/B testing - Run experiments to optimize your game
• Over-the-air updates - Push game config changes without app store updates
• In-game events - Schedule and manage time-limited content
• Economy management - Fine-tune currencies, rewards, and pricing
• Player support tools - Resolve issues with built-in admin features

Yes! Metaplay includes a full guild framework with support for:

• Guild creation, joining, and management
• Guild-level data and state management
• Invite systems and member permissions
• Guild chat and messaging
• Leaderboards and leagues at both player and guild levels

The social features are built on Metaplay's multiplayer entity system, making them fully customizable and extensible to fit your game's specific needs.

Yes. Metaplay includes both async and synchronous matchmaking systems. The async matchmaker is production-ready and works by bucketing players by MMR (matchmaking rating) for fast opponent finding.

The synchronous matchmaker (for real-time PvP) is in active development. You implement the MMR algorithm; Metaplay handles bucketing, caching, and distribution.

Metaplay provides server-side IAP validation for Google Play, App Store, and Steam. Purchases are validated on the server to prevent cheating, and you define products in game configs (spreadsheets).

The system handles receipt validation, purchase history, and grants rewards through your game logic. Dynamic content purchases and subscriptions are supported.

Yes. Metaplay's analytics events system streams events to external storage including BigQuery and S3. You define custom analytics events in your game logic, and they're automatically exported.

The system supports high-volume streaming and integrates with your existing data pipelines.

Metaplay supports Google Sign-In, Google Play Games, Apple Game Center, Sign in with Apple, Facebook Login, Steam, ImmutableX Wallet, and custom web login.

The system handles account linking, conflict resolution, and authentication across platforms. You can enable multiple platforms simultaneously.

Game configs let you define game data (economies, localization, events) in spreadsheets or JSON. The SDK builds these into binary archives that are distributed via CDN.

You can push new configs over-the-air without client updates. Configs support validation, diffing, A/B testing variants, and custom build pipelines.

Yes. Metaplay's multiplayer entities system enables real-time gameplay. Entities (players, guilds, sessions) communicate via message passing with low latency.

The system supports direct connections between entities and can handle real-time PvP, cooperative play, and shared game states.

Player segments let you define groups of players based on flexible rules (level, spending, behavior, etc.). Segments are used by LiveOps features (A/B tests, events, offers, broadcasts) to target specific player groups.

You can view segment membership in the dashboard and use segments throughout your game logic.

Yes. Metaplay's experiments system lets you define config variants and target them to player segments. You can run A/B tests on game configs, economies, events, and any data-driven feature.

The dashboard provides experiment management, targeting, and statistics. Experiments integrate with analytics for result analysis.

Yes. Metaplay includes push notification support for iOS and Android. You can send notification campaigns from the LiveOps Dashboard, target specific player segments, and schedule notifications.

The system handles platform-specific configuration and delivery.

In-game events are config-driven, time-limited content that can be scheduled and targeted to player segments. Events support calendar-based schedules, player segment targeting, and dynamic behavior based on game state.

You define events in game configs and manage them from the LiveOps Dashboard.

Yes. Metaplay includes a leagues system with season-based divisions, progression, and rewards. Leagues support custom ranking algorithms, division management, and player progression.

Leaderboards are built on the same infrastructure and can be customized for your game's needs.

Yes. Metaplay supports in-game mail with attachments (currencies, items). You can send individual mails from the LiveOps Dashboard (for customer support) or schedule mass broadcasts to player segments.

Mails support rich content and are integrated with the player's inbox system.

Yes. The Metaplay Unity SDK supports WebGL builds. WebGL games connect to Metaplay servers via WebSocket, and all core features (player state, configs, LiveOps) work in WebGL.

Some platform-specific features (like native IAP) may have limitations.

Yes. Metaplay includes Web3 support and NFT integration. The SDK provides tools for integrating blockchain wallets (like ImmutableX) and managing NFT ownership.

You can build hybrid games that combine traditional F2P mechanics with Web3 features.

Metaplay's localization system integrates with game configs. You define localized strings in spreadsheets or JSON, and the SDK handles language selection, fallbacks, and runtime lookup.

Localization data is distributed via game configs and can be updated over-the-air.

Metaplay includes BotClient for load testing, automated testing frameworks (Playwright for dashboard, .NET unit tests, system tests), and time-skip for testing scheduled events.

The SDK also includes an embedded mock server for offline development and testing.

Yes. The LiveOps Dashboard is fully customizable. You can add custom pages, admin actions, visualizations, and workflows.

The dashboard is built with Vue/TypeScript and uses the same APIs your game server exposes. Many studios customize it extensively for their specific needs.

In-game offers are config-driven purchase opportunities that can be targeted to player segments and scheduled. Offers support dynamic content, time limits, and purchase limits.

You define offers in game configs and manage them from the LiveOps Dashboard.

Yes. Metaplay supports auto-renewing subscriptions for iOS and Android. The system handles subscription validation, renewal tracking, and expiration.

You can manage subscription products through game configs and view subscription status in the LiveOps Dashboard.

Yes. Metaplay is fully programmable—you can add custom server entities, extend existing entities, implement custom services, and integrate with third-party APIs.

The game server is a standard C# project that you can modify and extend as needed.

Metaplay's guild framework includes an invite system with invite codes, member management, roles, and permissions.

You can customize invite behavior, search/discovery, and member operations. Invites are persisted and can be shared across sessions.

Yes. Metaplay provides public web endpoints for integrating with external services. You can build custom HTTP endpoints, webhooks, and API integrations.

The system supports authentication, rate limiting, and custom business logic.

Metaplay offers a free tier for development and prototyping. Paid tiers (Pro and Enterprise) include managed cloud hosting, priority support, and SLA guarantees.

Pricing is based on your studio's needs—contact us for specific pricing or visit our pricing page. Self-hosting is always an option if you prefer to manage infrastructure yourself.

Yes! You can get started with Metaplay completely free. Download the SDK, explore our sample projects, and start building your game right away.

The free tier includes everything you need to prototype and develop your game. When you're ready to go to production, you can upgrade to a paid tier for managed infrastructure and priority support.

The free tier includes:

• Full access to the Metaplay SDK and source code
• All sample projects (Idler, HelloWorld, Orca)
• Community Discord support
• Documentation and guides
• Local development environment

You can build and test your entire game locally before considering a paid tier for cloud deployment.

The free tier has no hard limits on SDK usage or local development. When you're ready to deploy to production, you'll need a paid tier for managed cloud hosting.

You can continue using the free tier for development and testing indefinitely.

Yes. Self-hosting is always available and doesn't require a paid tier. You deploy Metaplay to your own cloud infrastructure (AWS, GCP, Azure) or on-premises.

Self-hosting gives you full control and can be more cost-effective at scale, but requires DevOps expertise.

Metaplay's pricing is tier-based, not usage-based. Once you're on a paid tier, you get managed hosting and support regardless of player count (within reasonable limits).

For very large games, we work with you on custom arrangements. Self-hosting has no per-player fees.

Pro tier includes managed cloud hosting, priority support, and standard SLAs. Enterprise tier adds dedicated support, custom SLAs, strategic consultation, and additional infrastructure options.

Enterprise is designed for large studios with multiple games or specific compliance/security requirements.

Production plans designed for scaling live games include a usage-based licence component that covers server costs as your game grows. The rate is €2.95 per 1,000 monthly DAU, and your first 5,000 DAU are included as part of your monthly base fee—so you only pay the per-DAU rate once you exceed that threshold.

On managed service plans, infrastructure costs are included—you won’t see a separate cloud bill. We handle provisioning, scaling, and optimization so you can focus on your game.

If you choose to self-host with an Enterprise plan, you’ll manage your own infrastructure costs directly. Metaplay’s architecture is designed for efficiency at scale, and our team will work with you to optimize your setup and keep costs predictable as you grow.

Yes. You can upgrade or downgrade tiers as your needs change. Many studios start on the free tier, move to Pro when they need managed hosting, and upgrade to Enterprise as they scale.

Metaplay is built from the ground up to scale horizontally. The game server uses an actor-based architecture where each player (and other entities like guilds) runs as an independent actor.

This means you can scale from a handful of players to millions simply by adding more server nodes. Load balancing happens automatically, and the system handles player distribution across nodes transparently.

Our cloud infrastructure (when using managed deployments) includes auto-scaling capabilities that respond to player load in real-time.

In Metaplay, the server is the source of truth for all game state. This provides several benefits:

• Cheat prevention - Players can't modify their state client-side
• Consistency - All players see the same game state
• Persistence - State is safely stored and backed up

The client can still run game logic locally for responsiveness (client-side prediction), but all actions are validated and executed on the server.

Yes! Metaplay is designed to integrate with existing Unity projects. The SDK provides clear integration points and documentation to help you migrate your game to use Metaplay's backend.

For new projects, we recommend starting with one of our sample projects and adapting it to your needs. For existing projects, our documentation includes migration guides and best practices. The Trash Dash tutorial demonstrates integrating Metaplay into an existing game.

Metaplay uses an actor-based architecture built on Akka.NET. Game entities (players, guilds, etc.) run as actors in memory, communicating via message passing.

Entities are distributed across Kubernetes pods and can scale horizontally. When inactive, entities hibernate to the database, freeing resources.

You write game logic once in C# and it runs on both client and server. The client predicts actions locally for responsiveness, while the server validates and executes them authoritatively.

Deterministic execution ensures both sides produce identical results, minimizing network traffic while preventing cheating.

Yes. Metaplay includes an embedded mock server that runs in the Unity editor. You can develop and test your game completely offline—no server setup required.

The mock server emulates enough functionality for client development, art iteration, and gameplay testing.

Metaplay supports both managed cloud deployments (via Metaplay Cloud) and self-hosting. For managed deployments, you use the Metaplay CLI to build and deploy to cloud environments.

We recommend setting up CI/CD pipelines for automated deployments. Self-hosting uses Kubernetes and Terraform.

Metaplay uses MySQL for persistence. Entities are serialized to the database when they hibernate (become inactive). Active entities run in memory for performance.

The system handles serialization, migrations, and data integrity automatically. You can connect directly to the database for advanced operations.

Migration depends on your current backend. Metaplay is designed for incremental adoption—you can start by adding cloud saves and LiveOps features without migrating everything at once.

We provide migration guides and best practices. The Trash Dash tutorial demonstrates integrating into an existing game.

Metaplay is highly efficient—typical games can run ~1000 concurrent players per vCPU. The actor-based architecture minimizes overhead, and entities only consume resources when active.

Horizontal scaling distributes load across multiple nodes. Most games see sub-100ms latency for player actions.

Clients connect via persistent TCP connections secured with TLS. In cloud deployments, load balancers route connections to available server nodes.

The connection is then routed to the node running the player's entity. Connections support real-time multiplayer with low latency.

Yes. Metaplay's logic version system lets you support multiple client versions simultaneously. You can define migration logic to handle older clients gracefully.

This is essential for live games where not all players update immediately.

When you update entity schemas, Metaplay automatically migrates persisted entities to the new version. You define migration logic that transforms old data to new formats.

Migrations run when entities are loaded from the database, ensuring all entities are up-to-date.

Metaplay includes BotClient for load testing. You can simulate thousands of concurrent players to test performance, find bottlenecks, and validate behavior under load.

The system also includes automated testing frameworks for unit tests, integration tests, and dashboard tests.

Metaplay provides comprehensive observability tools including logs, metrics, and Grafana dashboards. The LiveOps Dashboard shows player states, event streams, and incident reports.

You can export player states from production to local for deep debugging. Logs are searchable and filterable.

Yes. Metaplay uses a runtime options system that lets you configure the server via YAML files, environment variables, or command-line arguments.

You can override base configurations per environment and extend with custom options. All configuration is visible in the LiveOps Dashboard.

Multi-region deployments are supported for self-hosted infrastructure. Managed Metaplay Cloud currently supports single-region deployments.

For multi-region, you deploy separate game server instances per region and handle cross-region communication as needed.

UDP support is available for self-hosted multi-region deployments. Managed Metaplay Cloud currently uses TCP connections.

UDP can provide lower latency for real-time gameplay but requires more complex connection management.

Metaplay provides CI/CD integration guides for common platforms (GitHub Actions, GitLab CI, etc.). The typical flow: build game server → create deployment → deploy to environment.

The Metaplay CLI handles builds and deployments. We recommend automated deployments for all environments.

Metaplay uses a custom binary serialization format similar to Protocol Buffers but optimized for games. Serialization metadata is defined in C# using attributes—no external definition files needed.

The format supports references, class hierarchies, fixed-point math, and multiple views of the same data.

Yes. You can create custom server-only entities for game-specific features. Entities are actors that can communicate with other entities, persist to the database, and scale across the cluster.

This is useful for matchmaking services, guild recommenders, or custom game modes.

Metaplay includes GDPR-compliant data export tools. Players can request their data, and the system exports all player information in a structured format.

You can customize what data is included in exports. The LiveOps Dashboard provides tools for handling export requests.

Metaplay provides Grafana dashboards, Prometheus metrics, and comprehensive logging. You can monitor player counts, server performance, error rates, and custom metrics.

Alerts can be configured for critical issues. The LiveOps Dashboard provides high-level views of game health.

Yes. Metaplay's clustering system supports multiple game servers (for different games or environments) in a single Kubernetes cluster.

Entities are distributed across nodes, and you can configure which entities run on which nodes for optimization.

Metaplay Cloud handles automated backups for managed deployments. For self-hosted deployments, you configure backups using your cloud provider's tools (AWS RDS, GCP Cloud SQL, etc.).

The system supports database snapshots, exports, and imports for environment management.

Security is built into every layer of Metaplay:

• Server-authoritative design - All game logic runs on the server, preventing client-side cheating
• Encrypted communications - All client-server traffic is encrypted
• Secure deployments - Infrastructure follows cloud security best practices
• Access controls - Role-based access for your team in the dashboard
• Audit logging - Track all administrative actions

Metaplay deploys to your own cloud account (AWS, GCP, or Azure), meaning you retain full control over where your data is stored. You choose the region that best serves your players and meets your compliance requirements.

Data is encrypted at rest and in transit. We follow industry best practices for data protection and can support GDPR and other compliance requirements.

Metaplay's architecture is designed for compliance. Because you deploy to your own cloud infrastructure, you maintain control over data residency and can implement your own compliance controls.

We provide GDPR compliance tools (data export, deletion) and work with enterprise customers on SOC 2 and other certifications. Self-hosting gives you full control over compliance.

All client-server communication is encrypted with TLS. Data at rest in the database is encrypted using your cloud provider's encryption (AWS RDS, GCP Cloud SQL, etc.).

You control encryption keys and can use your own key management systems. The system follows cloud security best practices.

You have full control over data access. For managed deployments, only your team and Metaplay support (with your permission) have access.

You can configure role-based access in the LiveOps Dashboard. Self-hosting gives you complete control. All access is logged in audit logs.

Yes. You can export all game data including player states, guilds, configs, and analytics. The system supports database exports, entity exports, and GDPR-compliant player data exports.

You own your data and can export it at any time.

Metaplay uses a secrets management system that integrates with your cloud provider's secret stores (AWS Secrets Manager, GCP Secret Manager, etc.). Secrets are stored securely and accessed at runtime.

You can rotate secrets without code changes. The LiveOps Dashboard provides tools for managing secrets.

All LiveOps Dashboard actions are logged in audit logs. You can view who did what, when, and from where. Audit logs are GDPR-compliant and help with security monitoring and compliance.

Logs are searchable and can be exported.

Metaplay includes built-in GDPR deletion tools. Players can request account deletion, and the system handles data removal according to GDPR requirements.

The LiveOps Dashboard provides tools for processing deletion requests and verifying completion.

Metaplay follows cloud security best practices including encrypted communications, secure authentication, role-based access control, audit logging, and regular security updates.

The codebase is regularly audited, and security bulletins are published for vulnerabilities. You can review all source code since it's included in the SDK.

The LiveOps Dashboard provides comprehensive player management tools. You can view player states, search and filter players, perform admin actions (ban, rename, reconnect accounts), view player logs and analytics, send in-game mail, and export player data.

The dashboard is designed for both developers and customer support.

LiveOps events are managed from the LiveOps Dashboard. You can schedule events, target player segments, view event status, and test events before going live.

The timeline view shows how events interact with each other. Events are defined in game configs and can be updated over-the-air.

A/B tests (experiments) are managed from the LiveOps Dashboard. You define config variants, create experiments, target player segments, and monitor results.

The dashboard shows experiment statistics and lets you promote winning variants. Experiments integrate with analytics for result analysis.

The LiveOps Dashboard provides tools for customer support including player lookup, state inspection, log viewing, incident reports, and in-game mail.

You can verify support requests by viewing player analytics and event history. The dashboard makes it easy for non-technical support staff to help players.

Metaplay provides Grafana dashboards for server metrics, player counts, error rates, and custom metrics. The LiveOps Dashboard shows high-level game health.

You can set up alerts for critical issues. Logs are searchable and filterable for debugging.

Game updates can be rolled out gradually using Metaplay's deployment system. You can deploy to staging first, test thoroughly, then roll out to production.

The system supports blue-green deployments and can roll back if issues are detected. Config updates can be pushed over-the-air without client updates.

Game configs are managed from the LiveOps Dashboard. You can view config builds, compare versions, see what's active, and publish new configs.

Configs are built from source data (spreadsheets, JSON) and distributed via CDN. The dashboard shows config diffs and validation results.

Metaplay provides incident reporting tools that bundle client logs, stack traces, and environment information. The LiveOps Dashboard shows incident reports and links to server logs in Grafana.

You can export player states from production to local for deep debugging. Support plans provide access to Metaplay engineers for critical issues.

Metaplay supports horizontal scaling by adding more server nodes. The system automatically distributes entities across nodes.

For managed deployments, scaling is handled automatically based on load. For self-hosted deployments, you configure auto-scaling or manual scaling. The system is designed to scale from thousands to millions of players.

Metaplay supports multiple environments (dev, staging, production) per project. Each environment is isolated with its own database and resources.

You can deploy different versions to different environments, move data between environments, and manage access separately. The LiveOps Dashboard shows which environment you're viewing.