Unity SDK.

using MatchKit.Matchmaking;
using UnityEngine;

public class MatchmakingDemo : MonoBehaviour
{
    // Add a MatchmakingClient component and point it at a MatchmakingConfig asset.
    [SerializeField] private MatchmakingClient matchmaking;
    private SseConnection _sse;

    void Start()
    {
        // externalId is your game's own stable user id (create + update key off it).
        var request = new PlayerRequest {
            externalId = "user-42",
            username = "ace",
            region = "eu",
            matchmakingMode = MatchmakingMode.MMR,
            ratingMode = RatingMode.TS,
        };

        matchmaking.CreatePlayer(request, created => {
            if (!created.IsSuccess) { Debug.LogError(created); return; }
            long playerId = created.Data.id;

            // Server pushes arrive over SSE: "queue-update" as a match forms,
            // "match-ended" carrying the player's fresh stats afterwards.
            _sse = matchmaking.Subscribe(playerId);
            _sse.OnEvent += (name, json) => Debug.Log($"{name}: {json}");

            // Join: region, modes and rating are resolved server-side from the
            // stored player; the client never sends a score.
            matchmaking.JoinQueue(playerId, gameMode: "ranked", teamSize: 5, r => Debug.Log(r));
        });
    }

    void OnDestroy() => _sse?.Close();
}

using System.Linq;
using MatchKit.Matchmaking;
using Mirror;
using Newtonsoft.Json.Linq;
using UnityEngine;

// MatchKit tells you *who* is in the match; Mirror moves the bytes between
// them. This is the entire handoff: on match-found, agree on a host and either
// StartHost() or StartClient(). Guard it behind the MATCHKIT_MIRROR define.
public class MirrorMatchHandoff : MonoBehaviour
{
    [SerializeField] private MatchmakingClient matchmaking;
    [SerializeField] private long localPlayerId;
    private SseConnection _sse;

    void Start()
    {
        // The same SSE stream the base client uses: "match-found" fires once a
        // full roster forms, carrying { matchId, teams[][] }.
        _sse = matchmaking.Subscribe(localPlayerId);
        _sse.OnEvent += OnServerEvent;
    }

    void OnServerEvent(string name, string json)
    {
        if (name != "match-found") return;

        // "teams" is every roster in stable order — two for a classic match,
        // ten for a ten-team FFA. Flatten it and you never mind the shape.
        long[] roster = JObject.Parse(json)["teams"]
            .SelectMany(team => team)
            .Select(entry => entry["playerId"].Value<long>())
            .ToArray();

        // Every client sees the identical roster, so a pure function of it
        // elects the same host with no round-trip: lowest playerId hosts.
        long hostId = roster.Min();

        if (localPlayerId == hostId)
        {
            NetworkManager.singleton.StartHost();
        }
        else
        {
            // Mirror only needs the host's address string. How you learn it is
            // your game's call: a relay, a Steam lobby, your own signalling.
            NetworkManager.singleton.networkAddress = ResolveHostAddress(hostId);
            NetworkManager.singleton.StartClient();
        }
    }

    void OnDestroy() => _sse?.Close();
}