Building an in-game economy is the part of a backend where mistakes cost real money, literally. A bug in matchmaking annoys players; a bug in commerce either charges someone and gives them nothing, or hands out items nobody paid for, and then you're issuing refunds and explaining yourself to a platform holder. And "commerce" isn't one thing: it's virtual currencies, a catalog and store, real-money purchases validated across every platform's storefront, entitlements that have to grant everywhere, and the harder edges most teams underestimate, player trading, fraud, and tax. A backend can be excellent at the virtual-goods layer and leave you to solve payments and fraud entirely on your own, so "best backend for in-game economy and commerce" depends on how much of that chain you need handled.
So this is a map, not a ranking. Below are ten backends sorted by which part of the economy-and-commerce problem each is best at, plus the payment specialists you'll pair with any of them, with the facts laid out so you can match them to your game. AccelByte builds one of these and commerce is one of its deeper areas, so it leads or co-leads several segments here, but you'll also see whole segments handed to PlayFab, to Nakama, and to payment specialists where they earn it. We'll be clear about the difference.
We cover AccelByte Public Cloud, AccelByte Private Cloud, PlayFab, Unity Gaming Services, Metaplay, Pragma, Heroic Labs (Nakama), Beamable, LootLocker, and Epic Online Services, and we flag the payment specialists (Stripe, Adyen, Xsolla) where the answer isn't a game backend at all. Public Cloud and Private Cloud are the same platform on commerce capability; they just differ on deployment, pricing, and compliance, so they're separate rows in the pricing tables and a single row in the capability tables. If you want the wider decision framework, the full backend roundup and the five questions that decide a backend choice are the companion pieces; if cross-platform purchases specifically are your problem, the cross-platform play comparison covers the identity side entitlements depend on.
Short version, if you need it fast: for virtual currencies and player inventory, AccelByte and PlayFab both go deep. For the store and catalog, PlayFab's Economy v2 and AccelByte are the heavyweights. For real-money IAP validated across stores, AccelByte and PlayFab lead, with AccelByte especially strong on cross-platform entitlement sync. For entitlements that grant everywhere a player owns them, AccelByte is the strongest, with PlayFab close. For player-to-player trading, no backend ships it as a finished feature (even PlayFab dropped native trading), so it's a build. For a free or open-source economy, Nakama or, in a narrow way, EOS. And for payments, fraud, chargebacks, and tax, the answer is a payment specialist, not a game backend. The rest of the page explains why.
A note on fairness before the tables. Commerce feature sets and platform rules drift, and several vendors price by quote. Where a vendor publishes real numbers, we've used them; where they don't, we say so rather than guess. Verify anything load-bearing against current docs before you commit, especially platform-holder purchase rules, which change.
Read this for the broad strokes: how deep the virtual economy goes, whether real-money IAP is validated across stores, whether entitlements reconcile across platforms, and whether payment processing is included (it never fully is). The segments below carry the reasoning.
| Platform | Virtual currency & inventory | Store & catalog | Cross-store IAP validation | Cross-platform entitlements |
|---|---|---|---|---|
| AccelByte Public Cloud | Yes (real + virtual, wallets) | Yes (regional pricing, DLC, codes) | Yes (Xbox, PSN, Steam, app stores) | Yes (grants everywhere) |
| AccelByte Private Cloud | Yes (real + virtual, wallets) | Yes (regional pricing, DLC, codes) | Yes (Xbox, PSN, Steam, app stores) | Yes (grants everywhere) |
| PlayFab | Yes (Economy v2, deep) | Yes (20GB catalogs, stacks) | Yes | Yes |
| Unity Gaming Services | Yes (Economy service) | Yes | Via Unity IAP | Limited (no console identity) |
| Metaplay | Yes (server-authoritative) | Yes (Offers) | Yes (App Store, Google, Steam) | Within Unity model |
| Pragma | Yes (+ clawback) | Not confirmed | Documented | Yes (native console identity) |
| Heroic Labs (Nakama) | Yes (wallet + ledger, Hiro) | Via Hiro / custom | Build it yourself | Via configuration |
| Beamable | Yes (managed) | Yes (Store) | Via integration | Limited |
| LootLocker | Yes (currencies) | Yes (In-Game Store) | Partial | Auth only |
| Epic Online Services | No (Ecom = EGS only) | No | No | No |
Commerce usually rides on each platform's base pricing, but there's a second cost layer unique to this capability: the payment processor's cut (typically a few percent plus a per-transaction fee) on every real-money purchase, which is separate from and often larger than the backend fee. Several vendors price by quote; those are marked, not guessed.
| Platform | Backend pricing model | Free tier | Entry paid tier |
|---|---|---|---|
| AccelByte Public Cloud | Usage-based (PCCU) | Free forever, 30 PCCU/day | Free |
| AccelByte Private Cloud | Usage-based (PCCU) + base fee | None, paid from the start | Starts at $1,500/mo + Usage-based (PCCU) |
| PlayFab | Metered, per-service, tiered plans | Free (capped at 1,000 lifetime players) | Starts at $99/mo |
| Unity Gaming Services | Metered, per-service | Per-service free tiers | Pay-as-you-go beyond free tiers |
| Metaplay | Flat rate by DAU | Metaplay Free (local development only) | Starts at €195/mo (Capped 5 DAU) |
| Pragma | Usage-based (DAU) + tier fee | 30-day trial | Starts at $2,499/mo (with Commerce module) |
| Heroic Labs (Nakama) | Free self-host, or usage-based managed | Free, unlimited (self-hosted) | Heroic Cloud quote-only |
| Beamable | Flat rate by tier | 90-day trial, no permanent free tier | Starts at $125/mo |
| LootLocker | Free tier, then quote-only | Free (non-commercial only) | Quote-only beyond trial |
| Epic Online Services | Free | Free, unlimited | Not applicable |
| Payment processor (all platforms) | Percent + per-transaction | Varies | ~2.9% + $0.30 typical (Stripe) |
The foundation of any game economy is currencies and inventory: soft currency players earn, hard currency they buy, and the items they own, tracked reliably so balances never drift and a player never loses what they paid for. The hard requirements are server authority (players can't edit their own balances), scale (millions of inventories, thousands of items each), and correctness under concurrent writes. This is a sub-case where two platforms go genuinely deep.
AccelByte provides wallets for both real and virtual currencies with server-side controls over how currency is earned, stored, and spent, plus a full entitlements and inventory system tied to its identity layer. PlayFab's Economy v2 is an equal heavyweight, arguably the most feature-dense inventory system here: durables, consumables, bundles, subscriptions, and containers, with inventories that hold 3,000-plus items per player using stacks and multiple collections, rebuilt on Azure to support hundreds of millions of players, and battle-tested in Minecraft and Sea of Thieves. The two are close, and the deciding factor is usually the rest of your stack and platform needs rather than the inventory model itself.
Nakama is a strong third if you want to own the economy: it provides a wallet with auditable ledger and, through its Hiro toolkit, currencies, inventory, and store scaffolding you control in code. Metaplay, Beamable, and LootLocker all handle currencies and inventory well within their models, with LootLocker a genuine option for indie economies. For deep, scalable virtual currency and inventory, AccelByte and PlayFab are the two to weigh first.
| Platform | Soft + hard currency | Inventory depth | Server-authoritative balances | Auditability |
|---|---|---|---|---|
| AccelByte | Yes | Full (entitlements + inventory) | Yes | Transaction history |
| PlayFab | Yes | Very deep (3,000+ items, stacks) | Yes | 4-year transaction history |
| Heroic Labs (Nakama) | Yes | Via Hiro + storage | Yes (server runtime) | Wallet ledger |
| Metaplay | Yes | Server state | Yes (by design) | Server-authoritative |
| Pragma | Yes | Yes (+ clawback) | Yes | Server-side |
| Beamable | Yes | Managed | Yes (microservices) | Managed |
| LootLocker | Yes | Indie-scale | Partial | Basic |
| Unity Gaming Services | Yes | Economy service | Via Cloud Code | Basic |
| Epic Online Services | No | No | N/A | N/A |
The store is where players actually spend: a catalog of items, bundles and offers, regional pricing, and the merchandising controls to run sales and rotate featured content without a client patch. The requirements are catalog scale, flexible bundling, and pricing that adapts by region and player segment. Two platforms lead, and it's close.
PlayFab's Economy v2 has one of the most complete catalog systems in the market: a unified catalog up to 20GB per entity, individual item documents (not one giant blob), bundles, recipes, stores, ratings and reviews, UGC, and OData-powered search, with segment-based pricing so you can offer different prices without touching game code. AccelByte matches it on the essentials that matter most for cross-platform commercial games: a catalog with item localization, regional pricing, purchase rules, store display settings, DLC management, and a Code Redemption service for redeemable codes (including third-party codes like Steam keys listed in your catalog). The distinction is subtle: PlayFab's catalog is marginally deeper on raw features like recipes and reviews, while AccelByte's is tightly integrated with its cross-platform entitlement layer (the next segment).
Metaplay's Offers and Offer Groups are strong for mobile live-service merchandising, Beamable has a solid Store, and LootLocker's In-Game Store is a real strength for indies. For a deep, flexible store and catalog, PlayFab and AccelByte are the two heavyweights.
| Platform | Catalog scale | Bundles / offers | Regional pricing | Merchandising controls |
|---|---|---|---|---|
| AccelByte | Large, localized | Yes | Yes | Yes (+ codes, DLC) |
| PlayFab | Up to 20GB per entity | Yes (+ recipes) | Yes (segment-based) | Yes (Game Manager) |
| Metaplay | Server-driven | Yes (Offer Groups) | Yes | Yes (LiveOps dashboard) |
| LootLocker | Indie-scale | Yes | Basic | Yes (config-driven) |
| Beamable | Managed | Yes | Yes | Via microservices |
| Unity Gaming Services | Economy catalog | Yes | Yes | Yes |
| Heroic Labs (Nakama) | Via Hiro / custom | Build it | Custom | Custom |
| Pragma | Not confirmed | Not confirmed | Not confirmed | Server-side |
| Epic Online Services | No (EGS only) | No | No | No |
This is the sub-case with the least tolerance for error, because it touches real money across every platform's storefront. When a player buys through the PlayStation, Xbox, Steam, App Store, or Google Play store, your backend has to validate that receipt with the platform, grant the entitlement, and handle the messy cases: refunds, chargebacks, and revoking an item when a purchase is reversed. Getting this wrong means lost revenue or angry players, and it's genuinely hard because each platform's rules differ.
AccelByte is especially strong here, with IAP validation and entitlement sync across Xbox, PlayStation, Steam, and the mobile app stores: it verifies the purchase, syncs the entitlement to its own database, and handles subscription lifecycles including auto-renewals, refunds, chargebacks, and chargeback reversals, with item revocation when a refund occurs. PlayFab is an equal peer, with receipt validation across the major stores and inventory grants tied to verified purchases, backed by Microsoft's platform relationships. Metaplay handles IAP validation across the App Store, Google Play, and Steam well for mobile-first titles. The rest vary: Unity's IAP works within its ecosystem, LootLocker and Beamable cover the common stores at their scale, and Nakama expects you to wire up validation in server code.
The critical thing all of these share, and it's the next point, is that none of them process the payment themselves; they validate a purchase the platform's store already processed. For validating and reconciling real-money purchases across stores, AccelByte and PlayFab are the strongest, with AccelByte's subscription and refund handling a particular strength.
| Platform | Store receipt validation | Subscription lifecycle | Refund / chargeback handling | Stores covered |
|---|---|---|---|---|
| AccelByte | Yes | Yes (auto-renewal, reversals) | Yes (revoke on refund) | Xbox, PSN, Steam, App Store, Google |
| PlayFab | Yes | Yes | Yes | Major console and mobile stores |
| Metaplay | Yes | Yes | Partial | App Store, Google, Steam |
| Unity Gaming Services | Via Unity IAP | Basic | Basic | Unity IAP stores |
| Beamable | Via integration | Partial | Partial | Common stores |
| LootLocker | Partial | Basic | Basic | Steam, mobile |
| Pragma | Documented | Yes (clawback) | Yes | Console stores |
| Heroic Labs (Nakama) | Build it yourself | Custom | Custom | Via server code |
| Epic Online Services | EGS ownership only | No | No | EGS only |
Here's the sub-case where AccelByte is genuinely the strongest, and it's a real problem for any cross-platform game: a player who buys a skin on PlayStation expects to have it on PC and mobile too, which means one entitlement ledger that every platform reconciles against, not five disconnected per-store inventories. This depends on cross-platform identity underneath (the same player recognized everywhere) plus an entitlement system that grants across platforms, and it's something most backends handle partially at best.
AccelByte is built around exactly this: purchases and entitlements sync to a single ledger keyed to its cross-platform identity, so a grant on one platform is honored everywhere the player owns the game, including across console storefronts, with DLC and entitlement management designed to keep access consistent across every supported platform. PlayFab is the close and genuine runner-up: its entity-based inventory works across the platforms your game runs on, and it's strong, though the cross-console-identity piece is where AccelByte's native console-identity focus gives it a slight edge. Pragma also documents native cross-platform entitlements with clawback across its seven identity providers, making it a real contender for this specific need. The honest picture: AccelByte leads here, PlayFab is close enough that your broader platform choice may decide it, and Pragma is a credible third.
Where this falls apart is the platforms without cross-platform identity, Unity's Economy is limited by its lack of native console identity, LootLocker reconciles only the identities it holds (console is auth-only), and EOS doesn't do general commerce at all. For entitlements that genuinely grant everywhere, AccelByte is the strongest pick, with PlayFab close behind.
| Platform | Single entitlement ledger | Grants across platforms | Console entitlement sync | Depends on cross-platform identity |
|---|---|---|---|---|
| AccelByte | Yes | Yes | Yes (Xbox, PSN) | Native |
| PlayFab | Yes | Yes | Yes | Via linking |
| Pragma | Yes | Yes (+ clawback) | Yes (documented) | Native (7 providers) |
| Metaplay | Within model | Unity-side | Via integration | Unity-side |
| Beamable | Partial | Partial | Limited | OAuth-based |
| Unity Gaming Services | Partial | Limited | No (no console identity) | Limited |
| LootLocker | Partial | Partial | Auth only | Unified accounts |
| Heroic Labs (Nakama) | Build it | Via config | Via config | Configurable |
| Epic Online Services | No | No | No | Epic ID (no commerce) |
Player-to-player trading, letting one player give or sell an item to another, and player-driven marketplaces are what some games are built around, and this is the sub-case where the honest answer is uncomfortable: no game backend here offers it as a complete, finished product, and the strongest commerce platform on this page actually removed it. So if trading is core to your game, plan to build it, and choose a backend for how well it supports that build rather than for a feature none of them fully ship.
The telling detail is PlayFab: its Economy v1 had a native trading API with atomic two-way item swaps, and Economy v2 removed it, so player-to-player trading now requires custom orchestration with Azure Functions, the same is true of drop tables and limited-supply items. That's not a knock on PlayFab specifically; it's a signal that safe trading (atomic, exploit-resistant, fraud-aware) is hard enough that platforms are cautious about shipping it generically. The best foundations for building it are the ones that give you real server-side control over the economy: Nakama is arguably the strongest base here because its wallet, ledger, and storage engine run your authoritative logic in server code (Go, TypeScript, or Lua), so you can implement atomic trades with full control, and being open source you can inspect and harden every path. AccelByte gives you server-authoritative entitlements and wallets to build trading against, PlayFab gives you the Azure Functions path, and Metaplay's server-authoritative model is a sound base too.
The realistic guidance: treat trading as custom work on top of a server-authoritative economy, budget for the exploit and fraud testing it demands, and pick Nakama if you want maximum control over the implementation or AccelByte or PlayFab if you're building it alongside their broader commerce stack.
| Platform | Native trading | Marketplace primitives | Server-authoritative economy to build on | Best-fit approach |
|---|---|---|---|---|
| AccelByte | No (buildable via Extend) | Entitlements, wallets | Yes | Build on entitlement layer |
| Heroic Labs (Nakama) | No (buildable) | Wallet, ledger, storage | Yes (open, code-controlled) | Build in server runtime |
| PlayFab | No (v2 removed it) | Inventory, currencies | Yes (via Azure Functions) | Custom orchestration |
| Metaplay | No (buildable) | Server-authoritative state | Yes | Build in C# server |
| Pragma | No (buildable) | Inventory, clawback | Yes | Build server-side |
| Beamable | No | Managed economy | Partial | Custom microservice |
| Unity Gaming Services | No | Economy items | Via Cloud Code | Custom |
| LootLocker | No | Basic economy | Partial | Limited |
| Epic Online Services | No | None | No | Not suitable |
Two kinds of team need this: those who want an economy layer at no cost, and those who need to own and customize the economy code outright. This is a segment where AccelByte is not the answer, and it's worth stating: its trial is free up to 30 concurrent players, but it's a managed commercial platform, not a free-forever or self-hostable economy.
Nakama is the clear pick for an owned economy: it's open source under Apache-2 and self-hostable for free, its wallet, ledger, and storage engine give you a real economic foundation, and the Hiro toolkit adds currencies, inventory, energy systems, and store scaffolding, all running on infrastructure you control and code you can modify. For a team that wants total control over its economy without a per-player platform fee, that's a strong answer, with the usual self-host tradeoff that you run the infrastructure. EOS belongs here only in a narrow sense: it's free, but its Ecom is limited to Epic Games Store ownership verification, so it is not a general in-game economy, no soft or hard currency store, no cross-store commerce, so it's the free choice only if all you need is EGS entitlement checking, which for most games isn't an economy at all.
The honest framing: for a genuinely free and self-hostable economy, Nakama is the answer; EOS is free but doesn't offer a general economy; and AccelByte, PlayFab, and the rest are managed platforms you pay for as you scale. If owning the economy code matters to you, Nakama leads this segment.
| Platform | Free economy tier | Open source | Self-host economy | General in-game commerce |
|---|---|---|---|---|
| AccelByte | Free up to 30 CCU | Enterprise-only | No | Yes (deep) |
| Heroic Labs (Nakama) | Self-host free | Yes (Apache-2) | Yes | Yes (wallet, Hiro) |
| Epic Online Services | Free | No (free SDK) | No | No (EGS ownership only) |
| Unity Gaming Services | Free tier | No | No | Yes (Economy service) |
| PlayFab | Free (capped) | No | No | Yes (deep) |
| LootLocker | Free (non-commercial) | SDKs only | No | Yes (indie) |
| Beamable | 90-day trial | Enterprise license | Own-cloud option | Yes |
| Metaplay | Local dev only | Ships source | Yes (any paid tier) | Yes |
| Pragma | Trial | Licensed fork | Your fork | Yes |
This is the segment where the honest answer is that you're asking the wrong category. Processing a real-money payment, handling PCI compliance, detecting fraud, managing chargebacks, and calculating and remitting tax across jurisdictions is a specialized, heavily regulated business, and no game backend on this page does it itself. Every one of them, including AccelByte and PlayFab, integrates a third-party payment specialist for this. Understanding that boundary is the point of this segment.
The specialists are payment service providers: Stripe and Adyen are the general leaders (real-time fraud tools, 3D Secure, chargeback management, PCI compliance, global payment methods), and Xsolla is the games-industry-specific option, built around global game payments, tax handling, and monetization with coverage of local payment methods worldwide. What a game backend gives you is the layer above payment: the AccelByte commerce system provides the catalog, wallet, and entitlement logic, and integrates payment aggregators that take care of the heavy lifting (PCI compliance, merchant accounts, tax calculation, secure card storage, fraud). PlayFab similarly relies on platform-store payment rails and external processors.
So the realistic architecture for direct real-money sales (outside the console and mobile stores, which handle their own payments) is a game backend for the economy plus a PSP for the money, and your fraud and tax posture comes largely from the PSP you choose, not the backend. Choose the backend for the commerce layer, and choose Stripe, Adyen, or Xsolla for the payment, fraud, and tax layer, and know that these are two decisions, not one.
The commerce stack has two layers owned by two different vendors: a game backend for the economy, a payment specialist for the money. Confusing the two is the most common mistake in game commerce.
| Layer | What it handles | Who provides it |
|---|---|---|
| Economy and entitlements | Catalog, currency, inventory, grants | Game backend (AccelByte, PlayFab, etc.) |
| Store receipt validation | Verifying console and mobile store purchases | Game backend |
| Payment processing | Taking the money, card handling, PCI | Payment specialist (Stripe, Adyen, Xsolla) |
| Fraud and chargebacks | Real-time fraud detection, dispute handling | Payment specialist |
| Tax calculation and remittance | Sales tax and VAT across jurisdictions | Payment specialist (or tax service) |
Two platforms deserve a specific placement for economy and commerce, because both are commonly considered here and one of them genuinely isn't a commerce platform at all.
Epic Online Services is excellent and free for identity, social, and multiplayer, but for economy and commerce it's essentially not a player: its Ecom feature verifies ownership of Epic Games Store items and nothing more, with no general in-game store, no soft or hard currency system, and no cross-store commerce. The right way to think about EOS for a monetized game is the EOS-plus-one pattern: use its free identity and social layers, and get your entire economy and commerce stack from a platform built for it. Treating EOS as a commerce option would be a mistake, and that's worth being direct about.
LootLocker is the opposite case, an indie-focused platform where commerce is a genuine strength: an In-Game Store, virtual currencies, catalogs, and DLC, all low-code and quick to stand up, which makes it a real option for a small team building a monetized game on PC and mobile. Its constraint is console: LootLocker's console support is authentication-only, so console purchase reconciliation isn't there, which matters if console is central to your monetization. For an indie game on PC and mobile that wants a working store fast, LootLocker is a legitimate pick; for cross-platform commercial games that include console, the heavyweights pull ahead.
| Sub-case | Best fit | |
|---|---|---|
| Virtual currency & inventory | AccelByte / PlayFab | AccelByte among leaders |
| Store, catalog & bundles | PlayFab / AccelByte | AccelByte among leaders |
| Real-money IAP validation | AccelByte / PlayFab | AccelByte among leaders |
| Cross-platform entitlements | AccelByte (PlayFab close) | AccelByte leads |
| Player-to-player trading | None built-in (build on Nakama) | leads elsewhere |
| Free & open-source economy | Nakama | leads elsewhere |
| Payments, fraud & tax | Stripe / Adyen / Xsolla (specialists) | leads elsewhere |
Commerce is a chain. AccelByte leads cross-platform entitlements outright and co-leads the core economy layer, while trading is a build, a free economy belongs to Nakama, and payments belong to specialists. That honest spread is what the page is for.
It depends on how much of the commerce chain you need handled, which is the whole reason this page is a map. For virtual currencies and inventory, AccelByte and PlayFab both go deep. For the store and catalog, PlayFab's Economy v2 and AccelByte are the heavyweights. For real-money IAP validated across stores, AccelByte and PlayFab lead, with AccelByte especially strong on subscriptions and refunds. For entitlements that grant everywhere, AccelByte is the strongest, with PlayFab close. For player trading, plan to build on a server-authoritative economy (Nakama gives the most control). For a free or open-source economy, Nakama. And for payments, fraud, and tax, a payment specialist like Stripe, Adyen, or Xsolla, never a game backend alone. AccelByte is a genuine leader across much of the core commerce layer, especially cross-platform entitlements, while conceding that trading is a build, a free economy belongs to Nakama, and payments belong to specialists.
Figure out which parts of the chain are hard for your game, virtual economy, cross-store purchases, entitlements, trading, or payments, and the options collapse to a backend or two plus a payment specialist worth a serious trial. Pick those, then build your real purchase-and-grant flow end to end and test the ugly paths: a refund, a chargeback, a cross-platform grant. That's the test that actually answers this.