Finding the Best Region for a Player

GameFlow exposes lightweight ping endpoints for each region so game clients can measure latency and select the best region for a match. Both HTTP and UDP are supported.

Ping Endpoints

Each region exposes a ping endpoint over two protocols:

• HTTP, GET returns 200 OK with minimal payload. Simple, works everywhere, subject to TLS/TCP handshake overhead.
• UDP, echo server on port 8080. Sends back packet payload verbatim. Closer to real gameplay traffic, no handshake, lower overhead.

Region	HTTP	UDP
US East	https://us-east.ping.gameflow.gg	us-east.ping.gameflow.gg:8080
US West	https://us-west.ping.gameflow.gg	us-west.ping.gameflow.gg:8080
EU Central	https://eu-central.ping.gameflow.gg	eu-central.ping.gameflow.gg:8080
AP Southeast	https://ap-southeast.ping.gameflow.gg	ap-southeast.ping.gameflow.gg:8080

Prefer UDP for matchmaking decisions, measured RTT matches what the game server connection will experience. Use HTTP when UDP is blocked (restrictive networks, browsers).

Measuring Latency

Send a request to each endpoint and measure round-trip time. For UDP, send a small payload and wait for the echo. Compare results to pick the lowest-latency region.

HTTP

Unity

using System.Collections;
using System.Diagnostics;
using UnityEngine;
using UnityEngine.Networking;

public class RegionPing : MonoBehaviour
{
    private static readonly string[] Regions = {
        "us-east", "us-west", "eu-central", "ap-southeast"
    };

    public void PingAllRegions()
    {
        foreach (var region in Regions)
        {
            StartCoroutine(PingRegion(region));
        }
    }

    private IEnumerator PingRegion(string region)
    {
        var url = $"https://{region}.ping.gameflow.gg";
        var sw = Stopwatch.StartNew();

        using var request = UnityWebRequest.Get(url);
        yield return request.SendWebRequest();

        sw.Stop();

        if (request.result == UnityWebRequest.Result.Success)
        {
            UnityEngine.Debug.Log($"Ping to {region}: {sw.ElapsedMilliseconds} ms");
        }
    }
}

Unreal Engine

#include "HttpModule.h"
#include "Interfaces/IHttpRequest.h"
#include "Interfaces/IHttpResponse.h"

void UMySubsystem::PingRegion(const FString& Region)
{
    FString Url = FString::Printf(TEXT("https://%s.ping.gameflow.gg"), *Region);

    double StartTime = FPlatformTime::Seconds();

    TSharedRef<IHttpRequest> Request = FHttpModule::Get().CreateRequest();
    Request->SetURL(Url);
    Request->SetVerb(TEXT("GET"));
    Request->OnProcessRequestComplete().BindLambda(
        [StartTime, Region](FHttpRequestPtr Req, FHttpResponsePtr Res, bool bSuccess)
        {
            if (bSuccess && Res.IsValid())
            {
                double Ms = (FPlatformTime::Seconds() - StartTime) * 1000.0;
                UE_LOG(LogTemp, Log, TEXT("Ping to %s: %.0f ms"), *Region, Ms);
            }
        });
    Request->ProcessRequest();
}

// Ping all regions
void UMySubsystem::PingAllRegions()
{
    TArray<FString> Regions = {
        TEXT("us-east"), TEXT("us-west"),
        TEXT("eu-central"), TEXT("ap-southeast")
    };
    for (const FString& Region : Regions)
    {
        PingRegion(Region);
    }
}

Godot

extends Node

const REGIONS = ["us-east", "us-west", "eu-central", "ap-southeast"]

func ping_all_regions():
    for region in REGIONS:
        ping_region(region)

func ping_region(region: String):
    var http = HTTPRequest.new()
    add_child(http)
    http.request_completed.connect(_on_ping_completed.bind(region, http))

    var url = "https://%s.ping.gameflow.gg" % region
    var start = Time.get_ticks_msec()
    http.set_meta("start_time", start)
    http.request(url)

func _on_ping_completed(result: int, response_code: int, _headers: PackedStringArray, _body: PackedByteArray, region: String, http: HTTPRequest):
    if result == HTTPRequest.RESULT_SUCCESS:
        var ms = Time.get_ticks_msec() - http.get_meta("start_time")
        print("Ping to %s: %d ms" % [region, ms])
    http.queue_free()

JavaScript

const REGIONS = ["us-east", "us-west", "eu-central", "ap-southeast"];

async function pingRegion(region) {
  const url = `https://${region}.ping.gameflow.gg`;
  const start = performance.now();
  await fetch(url);
  const ms = Math.round(performance.now() - start);
  console.log(`Ping to ${region}: ${ms} ms`);
  return { region, ms };
}

async function pingAllRegions() {
  const results = await Promise.all(REGIONS.map(pingRegion));
  results.sort((a, b) => a.ms - b.ms);
  console.log(`Best region: ${results[0].region} (${results[0].ms} ms)`);
  return results;
}

Go

package ping

import (
	"fmt"
	"net/http"
	"sort"
	"sync"
	"time"
)

var Regions = []string{"us-east", "us-west", "eu-central", "ap-southeast"}

type Result struct {
	Region string
	Ms     int64
}

func PingRegion(region string) (Result, error) {
	url := fmt.Sprintf("https://%s.ping.gameflow.gg", region)
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		return Result{}, err
	}
	resp.Body.Close()
	ms := time.Since(start).Milliseconds()
	return Result{Region: region, Ms: ms}, nil
}

func PingAllRegions() ([]Result, error) {
	var (
		mu      sync.Mutex
		results []Result
		wg      sync.WaitGroup
	)

	for _, r := range Regions {
		wg.Add(1)
		go func(region string) {
			defer wg.Done()
			res, err := PingRegion(region)
			if err != nil {
				return
			}
			mu.Lock()
			results = append(results, res)
			mu.Unlock()
		}(r)
	}

	wg.Wait()
	sort.Slice(results, func(i, j int) bool { return results[i].Ms < results[j].Ms })
	return results, nil
}

Rust

use std::time::Instant;

const REGIONS: &[&str] = &["us-east", "us-west", "eu-central", "ap-southeast"];

pub struct PingResult {
    pub region: String,
    pub ms: u128,
}

pub async fn ping_region(region: String) -> Result<PingResult, reqwest::Error> {
    let url = format!("https://{}.ping.gameflow.gg", region);
    let start = Instant::now();
    reqwest::get(&url).await?;
    let ms = start.elapsed().as_millis();
    Ok(PingResult { region, ms })
}

pub async fn ping_all_regions() -> Vec<PingResult> {
    let mut handles = Vec::new();
    for &region in REGIONS {
        handles.push(tokio::spawn(ping_region(region.to_string())));
    }

    let mut results = Vec::new();
    for handle in handles {
        if let Ok(Ok(result)) = handle.await {
            results.push(result);
        }
    }
    results.sort_by_key(|r| r.ms);
    results
}

UDP

Send a small packet to port 8080 and time the echo. No handshake, so RTT reflects raw network latency.

Unity

using System.Diagnostics;
using System.Net.Sockets;
using System.Text;
using UnityEngine;

public static class UdpPing
{
    public static int? Ping(string region, int timeoutMs = 2000)
    {
        using var udp = new UdpClient();
        udp.Client.ReceiveTimeout = timeoutMs;
        udp.Connect($"{region}.ping.gameflow.gg", 8080);

        var payload = Encoding.ASCII.GetBytes("ping");
        var sw = Stopwatch.StartNew();
        udp.Send(payload, payload.Length);

        try
        {
            System.Net.IPEndPoint ep = null;
            udp.Receive(ref ep);
            sw.Stop();
            return (int)sw.ElapsedMilliseconds;
        }
        catch (SocketException) { return null; }
    }
}

Unreal Engine

#include "Sockets.h"
#include "SocketSubsystem.h"
#include "Interfaces/IPv4/IPv4Address.h"
#include "IPAddress.h"

void UMySubsystem::PingRegionUDP(const FString& Region)
{
    ISocketSubsystem* SS = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
    FString Host = FString::Printf(TEXT("%s.ping.gameflow.gg"), *Region);

    auto Addr = SS->GetAddressFromString(Host);
    if (!Addr.IsValid()) return;
    Addr->SetPort(8080);

    FSocket* Socket = SS->CreateSocket(NAME_DGram, TEXT("ping"), false);
    const uint8 Payload[] = { 'p', 'i', 'n', 'g' };
    int32 Sent = 0;

    double Start = FPlatformTime::Seconds();
    Socket->SendTo(Payload, sizeof(Payload), Sent, *Addr);

    uint8 Buf[64];
    int32 Read = 0;
    Socket->Wait(ESocketWaitConditions::WaitForRead, FTimespan::FromSeconds(2.0));
    Socket->RecvFrom(Buf, sizeof(Buf), Read, *Addr);

    double Ms = (FPlatformTime::Seconds() - Start) * 1000.0;
    UE_LOG(LogTemp, Log, TEXT("UDP ping %s: %.0f ms"), *Region, Ms);

    SS->DestroySocket(Socket);
}

Godot

extends Node

const REGIONS = ["us-east", "us-west", "eu-central", "ap-southeast"]

func ping_region_udp(region: String) -> int:
    var udp := PacketPeerUDP.new()
    var err := udp.connect_to_host("%s.ping.gameflow.gg" % region, 8080)
    if err != OK:
        return -1

    var start := Time.get_ticks_msec()
    udp.put_packet("ping".to_utf8_buffer())

    var deadline := start + 2000
    while udp.get_available_packet_count() == 0 and Time.get_ticks_msec() < deadline:
        await get_tree().process_frame

    if udp.get_available_packet_count() == 0:
        return -1
    udp.get_packet()
    return Time.get_ticks_msec() - start

Node.js

import dgram from "node:dgram";

const REGIONS = ["us-east", "us-west", "eu-central", "ap-southeast"];

function pingRegionUDP(region, timeoutMs = 2000) {
  return new Promise((resolve) => {
    const sock = dgram.createSocket("udp4");
    const payload = Buffer.from("ping");
    const start = process.hrtime.bigint();

    const timer = setTimeout(() => {
      sock.close();
      resolve({ region, ms: null });
    }, timeoutMs);

    sock.once("message", () => {
      clearTimeout(timer);
      const ms = Number((process.hrtime.bigint() - start) / 1_000_000n);
      sock.close();
      resolve({ region, ms });
    });

    sock.send(payload, 8080, `${region}.ping.gameflow.gg`);
  });
}

// Browsers cannot send UDP, use HTTP fallback in-browser.

Go

package ping

import (
	"fmt"
	"net"
	"time"
)

func PingRegionUDP(region string) (Result, error) {
	addr := fmt.Sprintf("%s.ping.gameflow.gg:8080", region)
	conn, err := net.Dial("udp", addr)
	if err != nil {
		return Result{}, err
	}
	defer conn.Close()

	conn.SetDeadline(time.Now().Add(2 * time.Second))

	start := time.Now()
	if _, err := conn.Write([]byte("ping")); err != nil {
		return Result{}, err
	}

	buf := make([]byte, 64)
	if _, err := conn.Read(buf); err != nil {
		return Result{}, err
	}
	return Result{Region: region, Ms: time.Since(start).Milliseconds()}, nil
}

Rust

use std::net::UdpSocket;
use std::time::{Duration, Instant};

pub fn ping_region_udp(region: &str) -> std::io::Result<u128> {
    let sock = UdpSocket::bind("0.0.0.0:0")?;
    sock.connect(format!("{}.ping.gameflow.gg:8080", region))?;
    sock.set_read_timeout(Some(Duration::from_secs(2)))?;

    let start = Instant::now();
    sock.send(b"ping")?;

    let mut buf = [0u8; 64];
    sock.recv(&mut buf)?;
    Ok(start.elapsed().as_millis())
}

Using the Best Region

Once you've determined the best region, pass it when requesting a game server via the GameFlow API. There are two approaches depending on your setup.

Standalone Server

Start a one-off game server with POST /v1/games/:gameId/servers. GameFlow provisions the server and blocks until it's ready, returning its IP and port.

TypeScript / JavaScript

const bestRegion = (await pingAllRegions())[0].region;

const response = await fetch(
  `https://api.gameflow.gg/v1/games/${gameId}/servers`,
  {
    method: "POST",
    headers: { "X-Api-Key": apiKey },
    body: JSON.stringify({
      region: bestRegion,
      buildId: "build_abc123",
      payload: JSON.stringify({ players, teamA, teamB }),
    }),
  }
);

const { server } = await response.json();
// server.address, server.port

Go

results, _ := PingAllRegions()
bestRegion := results[0].Region

body, _ := json.Marshal(map[string]string{
    "region":  bestRegion,
    "buildId": "build_abc123",
    "payload": `{"players":["p1","p2"]}`,
})

req, _ := http.NewRequest("POST",
    fmt.Sprintf("https://api.gameflow.gg/v1/games/%s/servers", gameId),
    bytes.NewReader(body),
)
req.Header.Set("X-Api-Key", apiKey)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

Rust

let results = ping_all_regions().await;
let best_region = &results[0].region;

let client = reqwest::Client::new();
let res = client
    .post(format!(
        "https://api.gameflow.gg/v1/games/{}/servers",
        game_id
    ))
    .header("X-Api-Key", api_key)
    .json(&serde_json::json!({
        "region": best_region,
        "buildId": "build_abc123",
        "payload": r#"{"players":["p1","p2"]}"#,
    }))
    .send()
    .await?;

Fleet Allocation (Autoscaling)

If you have autoscaling configured via a fleet, allocate a pre-warmed server with POST /v1/fleets/:gameId/allocate. This returns an already-running server from the pool, so it's faster than starting a standalone server.

TypeScript / JavaScript

const bestRegion = (await pingAllRegions())[0].region;

const response = await fetch(
  `https://api.gameflow.gg/v1/fleets/${gameId}/allocate`,
  {
    method: "POST",
    headers: { "X-Api-Key": apiKey },
    body: JSON.stringify({
      region: bestRegion,
      payload: JSON.stringify({ players, teamA, teamB }),
    }),
  }
);

const { allocation } = await response.json();
// allocation.address, allocation.port

Go

results, _ := PingAllRegions()
bestRegion := results[0].Region

body, _ := json.Marshal(map[string]string{
    "region":  bestRegion,
    "payload": `{"players":["p1","p2"]}`,
})

req, _ := http.NewRequest("POST",
    fmt.Sprintf("https://api.gameflow.gg/v1/fleets/%s/allocate", gameId),
    bytes.NewReader(body),
)
req.Header.Set("X-Api-Key", apiKey)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

Rust

let results = ping_all_regions().await;
let best_region = &results[0].region;

let client = reqwest::Client::new();
let res = client
    .post(format!(
        "https://api.gameflow.gg/v1/fleets/{}/allocate",
        game_id
    ))
    .header("X-Api-Key", api_key)
    .json(&serde_json::json!({
        "region": best_region,
        "payload": r#"{"players":["p1","p2"]}"#,
    }))
    .send()
    .await?;

See the Custom Game Backend guide for a full integration walkthrough.

Best Practices

• Prefer UDP when available, matches real gameplay traffic and avoids TLS/TCP handshake overhead. Fall back to HTTP when UDP is blocked (browsers, restrictive corporate networks).
• Ping on game launch or lobby entry, avoid pinging mid-match to reduce unnecessary network traffic.
• Let the player override, display the results and allow the player to manually select a region if they prefer.
• Discard the first ping, HTTP includes TLS handshake overhead; UDP may warm up DNS/routing caches. Drop the first sample and average the rest.
• Ping multiple times and average, a single request can be affected by cold connections or transient network conditions. Averaging 3-5 pings per region gives a more stable result.
• Set a timeout on UDP, UDP does not guarantee delivery. Treat no-response within ~2s as a failed sample and retry or mark region unreachable.