> For the complete documentation index, see [llms.txt](https://sdk.metamarket.tech/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://sdk.metamarket.tech/evaluate-and-integrate/integration-overview.md).

# Integration Overview

If you are integrating an external game, this is your path. Your client talks to MetaMarket through the edge gateway, a proxy in front of the game engine, using either `Game.Sdk` (the typed .NET client) or the HTTP API directly. You hold no platform-wide credentials, and your client addresses only the tenant it is provisioned for. That is the whole external surface, and the rest walks through it.

Before any of this, your game has to be registered and the SDK delivered to you. [Getting Access](/evaluate-and-integrate/getting-access.md) covers both.

## The game door

An external game does not talk to the engine or the shared balance directly. Every call goes through the edge gateway, which forwards it to the game engine. The engine serves your tenant's event and player calls itself, and proxies the auth calls (`/api/auth/*`) on to the Hub under its own platform credential. Those auth calls carry no app id, because identity is app-agnostic.

The gateway is the security boundary. The SDK is not, and the difference matters if you integrate over raw HTTP.

`Game.Sdk` takes one gateway URL and one app id at startup and stamps that id on every request. But the gateway holds your app secret server-side and refuses any app id it is not configured to serve, so a raw HTTP client is constrained in exactly the same way. The SDK stamping is a convenience, not the thing keeping you in your tenant.

Shared platform data is out of reach on a different basis again. The platform currency and loyalty standing are gated at the platform rather than by the tenant header. [Security and Tenant Isolation](/architecture-and-trust/security-and-tenant-isolation.md) sets out how each control is enforced, and why reaching several tenants from one process is an internal path only.

```mermaid
flowchart LR
    GameApp["Your game client"] --> GameSdk["Game.Sdk or HTTP"]
    GameSdk --> Gateway["Edge gateway<br/>(holds your app secret)"]
    Gateway --> Engine["Game engine<br/>(serves your tenant)"]
    Engine -->|"auth calls (/api/auth/*)"| Hub["Hub<br/>(identity + platform currency)"]
    Engine -->|"platform value"| Hub
```

## First-party modules use a different path

MetaMarket's own modules, such as the platform portal, the shop, and the wheel, run as first-party tenants and reach the engine through a direct path that can address several tenants from one client. That path is internal-only and is not documented here, and an external integration never uses it. If you want the trust model behind the distinction, it is in [Roles and permissions](/architecture-and-trust/users-and-actors.md); otherwise skip this section.

## Raw REST is always underneath

Neither SDK adds a proprietary protocol. A *mutating* call returns the same JSON envelope: a `data` field plus three side channels, `effects`, `mutations`, and `directives`. Read-only queries return their result directly, and the auth-token calls return their own token shapes. A client that doesn't want either SDK can call the HTTP endpoints directly and parse the same envelope by hand. See [HTTP API](/evaluate-and-integrate/api-guide.md) for the raw endpoint surface. The SDKs exist to save you from writing that HTTP boilerplate and directive-handling loop yourself, not to hide anything the REST layer doesn't already expose.

For where each part of the platform stands today, see [Product availability](/overview/current-scope.md).

## Where to go next

* Getting registered and receiving the SDK: [Getting Access](/evaluate-and-integrate/getting-access.md)
* Deciding which door applies to your situation: [Integration Options](/evaluate-and-integrate/integration-options.md)
* One concrete path from zero to a working call: [Integration walkthrough](/evaluate-and-integrate/quickstart.md)
* Full SDK surface and client setup: [SDK Guide](/evaluate-and-integrate/sdk-guide.md)
* Calling the HTTP API directly, the routes an external integration uses: [HTTP API](/evaluate-and-integrate/api-guide.md)
* How device/player auth works on either door: [Authentication](/evaluate-and-integrate/authentication.md)