GameLiftMatch
Amazon GameLift matchmaking for Blueprints and C++

Overview

GameLiftMatch is the game-client side of Amazon GameLift for Unreal Engine 4.27 and 5.8. Players get temporary AWS credentials from a Cognito identity pool and talk to GameLift directly, so a matchmaking flow needs no backend of your own. Requests run on background worker threads with automatic retries; every result arrives on the game thread.

• Find Match: one node that submits a FlexMatch ticket, reports every status change, asks for acceptance when the rule set needs it and returns the server address with a player session per player.
• Start Matchmaking, Wait For Match, Accept Match, Stop Matchmaking for full control over tickets and parties.
• Start Game Session Placement + Wait For Placement: new sessions through queues, steered by player latency.
• Search Game Sessions, Describe Game Sessions, Create Game Session, Create Player Session: server browsers and direct sessions.
• Measure Region Latencies: per-region round-trip times, ready to feed into matchmaking and placement.
• Make Connect URL and Travel To Game Session: join the server with ?PlayerSessionId= in the URL.

Requirements

Installation

1. Install GameLiftMatch from Fab into your engine, or copy the GameLiftMatch folder into your project's Plugins folder.
2. Enable GameLiftMatch in Edit > Plugins and restart the editor.
3. Open Project Settings > Plugins > GameLiftMatch and set Region, Identity Pool Id and your defaults (Default Matchmaking Configuration, Default Queue Name, Default Alias Id).
4. C++ only: add PublicDependencyModuleNames.Add("GameLiftMatch"); to your Build.cs.

Setting up AWS

1. Upload your dedicated server build and create a fleet (and preferably an alias that points to it) in the GameLift console. Note the home region.
2. For queue placement: create a game session queue with your fleets or aliases as destinations.
3. For matchmaking: create a FlexMatch rule set and a matchmaking configuration that uses the queue. Player attributes and latency rules in the rule set must match what the client sends.
4. In Amazon Cognito create an identity pool. Enable guest access if players may matchmake before signing in, and add your identity providers (for example a Cognito user pool).
5. Attach a policy to the IAM role the pool gives to players (authenticated and/or guest) that allows only the GameLift actions the client uses:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": [
      "gamelift:StartMatchmaking",
      "gamelift:DescribeMatchmaking",
      "gamelift:StopMatchmaking",
      "gamelift:AcceptMatch",
      "gamelift:StartGameSessionPlacement",
      "gamelift:DescribeGameSessionPlacement",
      "gamelift:StopGameSessionPlacement",
      "gamelift:SearchGameSessions",
      "gamelift:DescribeGameSessions",
      "gamelift:CreateGameSession",
      "gamelift:CreatePlayerSession"
    ],
    "Resource": "*"
  }]
}

Remove every action your game does not call. Many games only need the first four (FlexMatch) or the placement actions. CreateGameSession and CreatePlayerSession are only needed for direct sessions and server browsers. Where IAM supports resource-level permissions, you can narrow StartMatchmaking to your matchmaking configuration ARN, StartGameSessionPlacement to your queue ARN and CreateGameSession to your fleet or alias ARN. Check the GameLift entry of the IAM service authorization reference before you narrow a statement.

Game server side

GameLiftMatch is the client half. A player session id only reserves a slot. Your dedicated server process on the fleet must validate every connecting player. Read PlayerSessionId from the login options (for example in AGameModeBase::PreLogin with UGameplayStatics::ParseOption). Call GameLift's server-side AcceptPlayerSession with it and reject the login if that call fails. When the player leaves, call RemovePlayerSession. A reserved slot that is not accepted within 60 seconds lapses.

Quick start

FlexMatch in one node

1. On Begin Play call Measure Region Latencies (Regions empty = the settings list) and keep Latencies.
2. Call Find Match with the latencies. Leave Players empty for a solo player whose id is the Cognito identity id, or fill in one GameLiftMatch Player per party member with attributes such as skill (Number).
3. On Status Changed: show Ticket.Status and Estimated Wait Seconds.
4. On Requires Acceptance (only when the rule set asks for acceptance): show a dialog, then call Accept Match with Ticket.TicketId.
5. On Matched: call Travel To Game Session with Ticket.Connection.
6. On Failed: show Error.Message. To leave the queue, call Cancel on the node's return value; Find Match then also stops the ticket on AWS.

Queue placement

Start Game Session Placement (Max Players, Latencies) → Wait For Placement with Placement.PlacementId → On Placed → Travel To Game Session with Placement.Connection.

Server browser

Search Game Sessions with Filter hasAvailablePlayerSessions=true and Sort playerSessionCount DESC → list the sessions → Create Player Session with the chosen GameSessionId → Travel To Game Session with the returned connection.

Matchmaking nodes

All latent nodes run in the background, can be stopped with Cancel on their return value and fire exactly one final pin on the game thread.

Placement nodes

Session nodes

Fleet Id / Alias Id empty = the settings' Default Alias Id, then Default Fleet Id. When both are given, the fleet wins.

Functions

Region latency

Measure Region Latencies opens Samples TCP connections (default 3) to gamelift.<region>.amazonaws.com:443 for every region at the same time. It returns the average connect time in milliseconds, sorted fastest first, plus Best Region and the Failed Regions that did not answer within Timeout Seconds. It uses the engine's socket layer, so it works the same on Win64, Linux and Android. Regions empty = the settings' Latency Regions. List the regions and locations where your fleets run. The host pattern and port are in the advanced settings, so you can point them at your own endpoints.

FlexMatch only places a match in regions for which every player reported a latency. If your rule set has a latency rule, players without latencies are never matched.

Credentials

Player ids are the Cognito identity id by default. They are stable per signed-in user and per device for guests. This means the server can trust the id it sees in the player session.

C++ API

// Build.cs: PublicDependencyModuleNames.Add("GameLiftMatch");
#include "GameLiftMatchAsyncActions.h"
#include "GameLiftMatchLibrary.h"

UGameLiftMatchFindMatchAction* Find = UGameLiftMatchFindMatchAction::FindMatch(this, TEXT("MyConfig"),
    TArray<FGameLiftMatchPlayer>(), Latencies);
Find->OnMatched.AddDynamic(this, &UMyMenuWidget::HandleMatched);   // UFUNCTION(const FGameLiftMatchTicket&, const FGameLiftMatchError&)
Find->OnFailed.AddDynamic(this, &UMyMenuWidget::HandleFailed);
Find->Activate();

void UMyMenuWidget::HandleMatched(const FGameLiftMatchTicket& Ticket, const FGameLiftMatchError& Error)
{
    FString Url;
    UGameLiftMatchLibrary::TravelToGameSession(GetOwningPlayer(), Ticket.Connection, FString(), {}, Url);
}

Every latent node class (UGameLiftMatch...Action) works the same way: call the static factory, bind the dynamic delegates, then call Activate(). Results always arrive on the game thread.

Types

Settings

Project Settings > Plugins > GameLiftMatch (saved to DefaultGame.ini). Changes apply to the next request.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Includes the AWS SDK for C++ and the AWS Common Runtime (Apache License 2.0). Built and verified warning-free for Unreal Engine 4.27 and 5.8.