Source: https://gameye.com/unity-multiplay-to-gameye/

---
title: "Unity Multiplay to Gameye Migration Checklist (2026)"
description: "Migration checklist: Unity Multiplay to Gameye. Keep Matchmaker, remove the SDK, ship a Docker container, call one API."
---

Migration Guide

# Unity Multiplay to Gameye
Migration Checklist

Keep Unity Matchmaker. Remove the Multiplay SDK. Ship a Docker container. Call one API.

Unity Matchmaker Docker No SDK Required

Last modified October 16, 2026

Unity Multiplay Game Server Hosting shut down on March 31, 2026. Unity Matchmaker, Relay, Lobby, and Distributed Authority are all unaffected — only the dedicated server fleet layer is gone.

This checklist covers migrating from Multiplay to Gameye while keeping Unity Matchmaker as your matchmaking layer. The scope is the server hosting infrastructure — not your game logic.

## What stays the same

- Unity Matchmaker (rules, queues, ticket logic)
- Unity Relay
- Unity Lobby
- Netcode for GameObjects / your networking model
- Your authoritative game server logic
- Client connection flow
- Player-facing behaviour

The migration is an infrastructure swap underneath your existing stack.

## Prerequisites

- **Gameye Developer Trial account** — [start a trial](https://trial.gameye.com/), no sales call required
- **API token** — provided with your sandbox account. Include in all API requests as `Authorization: Bearer YOUR_TOKEN`
- **Docker installed** on your development machine
- **Docker Hub account** (Team or Large plan for private repos)
- **Linux dedicated server build** of your Unity project (Unity's Dedicated Server build target)

**API URLs:** Sandbox is `api.sandbox-gameye.gameye.net`, production is `api.production-gameye.gameye.net`. Examples below use the production URL — swap in the sandbox URL during integration testing.

## Phase 1: Remove Multiplay SDK

Strip out all Multiplay-specific code from your dedicated server build. With Gameye, there is no replacement SDK — your server binary runs as-is.

- Remove `IMultiplayService` initialization from your server startup
- Remove `MultiplayEventCallbacks` (server allocation, deallocation, error handlers)
- Remove any `ServerConfig` reads from the Multiplay service (e.g. server name, port, max players)
- Remove the `com.unity.services.multiplay` package from your `manifest.json`
- If you were using `MultiplayService.Instance.ReadyServerForPlayersAsync()` — remove it. Gameye determines server readiness through port availability, not an SDK call
- If you were using `MultiplayService.Instance.UnreadyServerAsync()` — remove it. Terminate sessions via `DELETE /session/{id}` from your backend, or set a TTL on session creation

**What replaces the SDK?** Nothing in your server binary. Gameye manages session lifecycle server-side. Your server just needs to:

- Start and listen on its configured port
- Accept player connections
- Run your game logic

That's it. No Gameye-specific code in the binary.

## Phase 2: Containerize your dedicated server

Package your Unity Linux dedicated server as a Docker image.

- Build a **Linux Dedicated Server** using Unity's Dedicated Server build target
- Create a `Dockerfile` in your project

```
FROM ubuntu:20.04

# Install dependencies your server needs (if any)
RUN apt-get update && apt-get install -y libssl1.1 \
&& rm -rf /var/lib/apt/lists/*

# Copy your built server
COPY ./BuildOutput /game

# Make the server executable
RUN chmod +x /game/YourGameServer

# Expose your game port (bridge networking)
EXPOSE 7777/udp

# Start the server
ENTRYPOINT ["/game/YourGameServer", "-batchmode", "-nographics"]
```

- Build and test locally: `docker build -t your-game:latest .`
- Run locally to verify it starts: `docker run -p 7777:7777/udp your-game:latest`
- Push to Docker Hub: `docker push your-org/your-game:latest`

**Networking modes:** Gameye supports bridge and host networking. Bridge mode (recommended for most studios) uses `EXPOSE` directives. Host mode reads Gameye-injected environment variables (`GAMEYE_PORT_{protocol}_{containerPort}`) at startup — see the [Dockerfile guide](https://gameye.com/docs/getting-started/2-docker-file/) for details.

## Phase 3: Configure Gameye

Register your application in the Gameye Admin Panel and verify your image works.

- Log in to the [Gameye Admin Panel](https://admin.gameye.com)
- Create an **Application** — set the image name matching your Docker Hub repository
- Configure networking: ports, protocol (UDP/TCP), networking mode
- Select your **deployment regions** (see [available locations](https://gameye.com/docs/api-v2/available-locations/))
- Set resource allocation (vCPU, RAM) matching your server requirements
- **Test launch** a container from the Admin Panel to verify it starts and is reachable
- Set up the Docker Hub **webhook** so Gameye pulls new images automatically when you push (see [Docker Hub setup](https://gameye.com/docs/getting-started/1-docker-hub/))

## Phase 4: Replace the allocation call

When Unity Matchmaker finds a match, allocate a Gameye session instead of a Multiplay server. Wherever your backend called Multiplay's fleet allocation API, replace it with a single POST to Gameye.

```
POST https://api.production-gameye.gameye.net/session
Authorization: Bearer YOUR_TOKEN
Content-Type: application/json

{
"location": "europe",
"image": "your-game",
"args": ["--max-players=10", "--game-mode=ranked"],
"env": {
"MATCH_ID": "abc-123"
},
"ttl": "1h"
}
```

Parse the response for connection details:

```
{
"id": "f7965a22-e327-4541-a30e-8262890d3a29",
"host": "203.0.113.42",
"ports": [
{ "type": "udp", "container": 7777, "host": 49152 }
]
}
```

- Return `host:port` to Unity Matchmaker / your game client for player connection
- Pass any match metadata (game mode, map, player list) via `args` or `env` — your server reads these at startup just like command-line arguments or environment variables

**Session IDs:** Gameye auto-generates a UUID if you omit `id`. If you want to track sessions against your match IDs, pass your own UUID.

**TTL:** Set a maximum session lifetime in seconds. When the TTL expires, the session terminates automatically. Alternatively, call `DELETE /session/{id}` from your backend when the match ends.

## Phase 5: Verify and cut over

- **Parallel testing:** Run Gameye alongside your existing setup (if you still have one) to validate performance
- Verify session starts in your target regions — check the Admin Panel for active containers
- Verify players can connect to the returned `host:port`
- Verify [log streaming](https://gameye.com/docs/api-v2/log-streaming/) works — check logs while a session is active
- Verify session cleanup — confirm containers terminate when you call `DELETE /session/{id}` or TTL expires
- Load test: create multiple concurrent sessions across regions
- Review [artifacts](https://gameye.com/docs/api-v2/artifacts/) — session files (logs, save data) are downloadable post-session
- When confident, point your production allocation backend at `api.production-gameye.gameye.net` and go live

## Quick reference: Multiplay to Gameye

| Multiplay concept | Gameye equivalent |
| --- | --- |
| Fleet / server profile | Application (configured in Admin Panel) |
| Server allocation API | `POST /session` |
| Server deallocation | `DELETE /session/{id}` or TTL expiry |
| `IMultiplayService` SDK | Not needed — no SDK in your server binary |
| `ReadyServerForPlayersAsync()` | Not needed — Gameye checks port availability |
| `UnreadyServerAsync()` | Not needed — terminate via API or TTL |
| Server logs (Multiplay dashboard) | [Admin Panel](https://gameye.com/docs/admin-panel/) + [log streaming API](https://gameye.com/docs/api-v2/log-streaming/) |
| Fleet scaling rules | Managed by Gameye — or configure [warm pools](https://gameye.com/docs/admin-panel/warm-pools/) |
| Regions | [Available locations](https://gameye.com/docs/api-v2/available-locations/) — configured per application |
| Per-server environment variables | `env` field in `POST /session` |
| Launch parameters | `args` field in `POST /session` |
| Multiplay dashboard | [Gameye Admin Panel](https://admin.gameye.com) |

``
`   What about Unity Matchmaker? Unity updated Matchmaker to support third-party hosting providers before the Multiplay shutdown deadline. Your matchmaking rules, player grouping, and ticket logic stay unchanged. The only change is what happens when a match is found — instead of Multiplay allocating a server, Gameye provisions one. The fastest path is Gameye's Unity Matchmaker Cloud Code module. Deploy it to your Unity project with the UGS CLI in around 15 minutes — it connects Unity Matchmaker directly to the Gameye Session API without any changes to your matchmaking rules or queue configuration. If you prefer to handle the allocation call yourself, replace the Multiplay fleet allocation with a single POST /session` to the Gameye API wherever your backend currently triggers an allocation.

Get started

## Start your free trial today.
No sales call required.

Get your API key, push your Docker image, and run your first session — before you commit to anything.

[Start Building →](https://trial.gameye.com/)  [Read the docs →](https://gameye.com/docs/)  [Join Discord →](https://discord.com/invite/QvJ3KH5max)

``
``
````