Unity Multiplay to Gameye
Migration Checklist

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 sandbox account — request access, provisioned within 24 hours
• 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)

---

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

---

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 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
• 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)
• 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)

---

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.gameye.io/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": 3600
}

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 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 — session files (logs, save data) are downloadable post-session
• When confident, point your production allocation backend at api.gameye.io and go live

---

Quick reference: Multiplay to Gameye

---

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, your backend calls POST /session on the Gameye API.

If you're using Unity Matchmaker's allocation callbacks, the integration point is where the callback currently triggers a Multiplay allocation. Replace that single call with the Gameye POST /session request above.

---

Get started

Sandbox access in 24 hours.
No sales call required.

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

Request sandbox access → Read the docs → Join Discord →