Last updated on November 10, 2025

Additional functions for Turn Manager in SDK

The Turn Manager API in the AGS SDK supports several utility functions for additional requirements of your game client.

Get TURN servers

This function is called by the game client to retrieve a list of all available TURN servers.

Unreal Engine
Unity Engine

AccelByteOnlineSubsystemPtr->GetApiClient()->TurnManager.GetTurnServersV2(THandler<FAccelByteModelsTurnServerList>::CreateLambda(
    [](const FAccelByteModelsTurnServerList& Result)
{
    UE_LOG(LogTemp, Log, TEXT("Get Turn Servers Success!"));
}),
FErrorHandler::CreateLambda([](const int32 ErrorCode, const FString& ErrorMessage)
{
    UE_LOG(LogTemp, Log, TEXT("Get Turn Servers Failed! [%d]: %s"), ErrorCode, *ErrorMessage);
}));

TurnServerList getTurnServerResult = null;
AccelByteSDK.GetClientRegistry().GetApi().GetTurnManager().GetTurnServers(result =>
{
    if (result.IsError)
    {
        // Do something if the operation fails
        UnityEngine.Debug.LogError($"failed to get TURN servers [{result.Error.Code}]:{result.Error.Message}");
        return;
    }

    // Do something if the operation succeeds
    getTurnServerResult = result.Value;
});

Get closest TURN server

This function automatically retrieves a list of all available TURN servers and pings all servers to provide the closest region.

Unreal Engine
Unity Engine

AccelByteOnlineSubsystemPtr->GetApiClient()->TurnManager.GetClosestTurnServerV2(THandler<FAccelByteModelsTurnServer>::CreateLambda(
    [](const FAccelByteModelsTurnServer& Result)
{
    UE_LOG(LogTemp, Log, TEXT("Get Closest Turn Server Success!"));
}),
FErrorHandler::CreateLambda([](const int32 ErrorCode, const FString& ErrorMessage)
{
    UE_LOG(LogTemp, Log, TEXT("Get Closest Turn Server Failed! [%d]: %s"), ErrorCode, *ErrorMessage);
}));

// Get all available TURN servers
TurnServerList getTurnServerResult = null;
AccelByteSDK.GetClientRegistry().GetApi().GetTurnManager().GetTurnServers(result =>
{
    if (result.IsError)
    {
        // Do something if the operation fails
        UnityEngine.Debug.LogError($"Failed to get TURN servers [{result.Error.Code}]:{result.Error.Message}");
        return;
    }

    // Do something if the operation succeeds
    getTurnServerResult = result.Value;
});

// Get the closest TURN server based on the server latencies
TurnServer closestTurnServer = null;
getTurnServerResult.GetClosestTurnServer()
    .OnFailed(error =>
    {
        // Do something if the operation fails
    })
    .OnSuccess(result =>
    {
        // Do something if the operation succeeds
        closestTurnServer = result;
    });

Get TURN server latency by region

Unreal Engine
Unity Engine

This function returns the total latency in milliseconds using a specific region in a parameter.

AccelByteOnlineSubsystemPtr->GetApiClient()->TurnManager.GetTurnServerLatencyByRegion(Region, THandler<int32>::CreateLambda(
    [&FuncName, &OutResponse, &bIsOk, &bIsDone](const int32& Result)
{
    UE_LOG(LogTemp, Log, TEXT("Get Turn Server Latency By Region Success!"));
}),
FErrorHandler::CreateLambda([&bIsDone](const int32 ErrorCode, const FString& ErrorMessage)
{
    UE_LOG(LogTemp, Log, TEXT("Get Turn Server Latency By Region Failed! [%d]: %s"), ErrorCode, *ErrorMessage);
}));

This function returns the total latency in milliseconds using a specific region in a parameter. You can adjust the useCase as needed. See Get TURN servers to get the getTurnServerResult value.

useCase:true: will use cached latency
useCase:false: will ping the server to get the latest latency

// Get this value from the result of GetTurnServers() interface
TurnServerList getTurnServersResult;
// Define a specific server
TurnServer turnServer = getTurnServerResult.servers[0];

// Generate specific server as a latency using latest latency
// Can be used to regenerate the latest latency without calling the GetTurnServers() interface
int latency;
turnServer.GetLatency(useCache: false)
    .OnFailed(error =>
    {
        // Do something if the operation fails
    })
    .OnSuccess(result =>
    {
        latency = result;
        // Do something if the operation succeeds
    });

Get TURN server latencies

Unreal Engine
Unity Engine

This function returns all available TURN server regions latencies.

AccelByteOnlineSubsystemPtr->GetApiClient()->TurnManager.GetTurnServerLatencies(THandler<TArray<TPair<FString, float>>>::CreateLambda(
    [&FuncName, &OutResponse, &bIsOk, &bIsDone](const TArray<TPair<FString, float>>& Result)
{
    UE_LOG(LogTemp, Log, TEXT("Get Turn Server Latencies Success!"));
}),
FErrorHandler::CreateLambda([&bIsDone](const int32 ErrorCode, const FString& ErrorMessage)
{
    UE_LOG(LogTemp, Log, TEXT("Get Turn Server Latencies Failed! [%d]: %s"), ErrorCode, *ErrorMessage);
}));

This function returns all available TURN server regions latencies map with latest latencies. Adjust the useCase as needed. See Get TURN servers to get the getTurnServerResult value.

// Get this value from the result of GetTurnServers() interface
TurnServerList getTurnServersResult;

// Generate all TURN servers as a latencies map with latest latencies
// Can be use to regenerate the latest latencies again without calling GetTurnServers() interface
// This map can be used for MatchmakingV2CreateTicketRequestOptionalParams on CreateMatchmakingTicket
Dictionary<string, int> latenciesMap = null;
getTurnServersResult.Value.GenerateLatenciesMap(useCache: false)
    .OnFailed(error =>
    {
        // Do something if the operation fails
    })
    .OnSuccess(result =>
    {
        latenciesMap = result;
        // Do something if the operation succeeds
    });

This function returns a specific TURN server latency map with latest latency. See Get TURN servers to get the getTurnServerResult value.

// Get this value from the result of GetTurnServers() interface
TurnServerList getTurnServersResult;
// define a specific server
TurnServer turnServer = getTurnServersResult.servers[0];

// Generate specific server as a latency map using latest latency
// Can be use to regenerate the latest latency again without calling GetTurnServers() interface
// This map can be used for MatchmakingV2CreateTicketRequestOptionalParams on CreateMatchmakingTicket
Dictionary<string, int> latencyMap = null;
turnServer.GenerateLatencyMap(useCache: false)
    .OnFailed(error =>
    {
        // Do something if the operation fails
    })
    .OnSuccess(result =>
    {
        latencyMap = result;
        // Do something if the operation succeeds
    });

Get cached latencies

Unreal Engine
Unity Engine

The AGS Unreal SDK caches latencies after pinging the available regions. This function returns cached latencies:

AccelByteOnlineSubsystemPtr->GetApiClient()->TurnManager.GetCachedLatencies();

This function returns cached latencies map from all servers:

info

See Get TURN servers to get the getTurnServerResult value.

// Get this value from the result of GetTurnServers() interface
TurnServerList getTurnServersResult;

// Generate all TURN servers as a latencies map using cached latencies
// Allow to get cached latencies without calling GetTurnServers() interface again (Only need to call that interface once)
// This map can be used for MatchmakingV2CreateTicketRequestOptionalParams on CreateMatchmakingTicket
Dictionary<string, int> latenciesMap = null;
getTurnServersResult.GenerateLatenciesMap(useCache: true)
    .OnFailed(error =>
    {
        // Do something if the operation fails
    })
    .OnSuccess(result =>
    {
        latenciesMap = result;
        // Do something if the operation succeeds
    });

This function returns a cached latency map from a specific server.

info

See Get TURN servers to get the getTurnServerResult value.

// Get this value from the result of GetTurnServers() interface
TurnServerList getTurnServersResult;
// define a specific server
TurnServer turnServer = getTurnServersResult.servers[0];

// Generate specific server as a latency map using cached latency
// Allow to get cached latency without calling GetTurnServers() interface again (Only need to call that interface once)
// This map can be used for MatchmakingV2CreateTicketRequestOptionalParams on CreateMatchmakingTicket
Dictionary<string, int> latencyMap = null;
turnServer.GenerateLatencyMap(useCache: true)
    .OnFailed(error =>
    {
        // Do something if the operation fails
    })
    .OnSuccess(result =>
    {
        latencyMap = result;
        // Do something if the operation succeeds
    });

Manually calculate latencies

Unity Engine

To retrieve the server list and skip latencies calculation, follow this code example:

GetTurnServerOptionalParameters optionalParameters = new GetTurnServerOptionalParameters();
optionalParameters.AutoCalculateLatency = false;
TurnServerList getTurnServerResult = null;
AccelByteSDK.GetClientRegistry().GetApi().GetTurnManager().GetTurnServers(optionalParameters, result =>
{
    if (result.IsError)
    {
        // Do something if the operation fails
        UnityEngine.Debug.LogError($"failed to get TURN servers [{result.Error.Code}]:{result.Error.Message}");
        return;
    }

    // Do something if the operation succeeds
    getTurnServerResult = result.Value;
});

The SDK also provide helper functions to calculate the latencies:

// Get this value from the result of GetTurnServers() interface
TurnServerList getTurnServerResult;
// Define a specific server
TurnServer turnServer = getTurnServerResult.servers[0];

#if !UNITY_WEBGL || UNITY_EDITOR
    AccelByte.Models.AccelByteResult<int ,Error> pingResult = AccelByte.Utils.Networking.UdpPing(turnServer.ip, (uint) turnServer.qos_port);
#else
    // Web platform doesn't support UDP
    // Latency must be estimated to the region by sending an HTTP request
    string url = AccelByte.Utils.Networking.GetTestServerUrlByRegion(turnServer.region);
    AccelByte.Models.AccelByteResult<int ,Error> pingResult = AccelByte.Utils.Networking.HttpPing(url);
#endif
    pingResult.OnSuccess(latency =>
    {
        Debug.Log($"Server {turnServer.region} has latency {latency} ms");
    });
    pingResult.OnFailed(error =>
    {
        Debug.LogWarning($"Failed calculating server {turnServer.region} latency.\n{error.Message}");
    });

Get TURN servers​

Get closest TURN server​

Get TURN server latency by region​

Get TURN server latencies​

Get cached latencies​

Manually calculate latencies​