Unreal Engine SDK

Coming soonC++ / Blueprints

A native Keme Unreal Engine plugin — with a drop-in support portal, a C++ API, and Blueprint-callable nodes — is on our roadmap but is not yet available. There is no Unreal plugin to download today, and any references to a KemeSupport module, UKemeSupportSubsystem, or similar native types are placeholders for the future release.

You don't need to wait, though. Keme is a REST-first platform, and every SDK we ship is a thin wrapper over the same HTTP contract. You can integrate your Unreal Engine 5 game with Keme CustomerOps today by calling the player-portal REST API directly from C++ (via the built-in HTTP module) or from Blueprints (via the HTTP / VaRest-style request nodes).

Note:Want to be notified when the native Unreal SDK ships? The REST integration below is forward-compatible — it uses the exact same endpoints the native plugin will wrap, so migrating later is a drop-in swap rather than a rewrite.

Core concepts

Two identifiers drive the entire integration. Understanding them up front makes the rest of this guide straightforward.

gameId — identifies your game / app (for example game-marble-sort). You set it once and send it when creating tickets. Valid ids come from your Keme dashboard (or the /portal/tickets/games endpoint).
gameUid — identifies a player uniquely within your game. The first time a player logs in, Keme auto-provisions the account — there is no separate registration step. A banned player's login returns HTTP 403.

REST quickstart

All player-portal requests go to the base URL below and send/receive JSON. Every response is wrapped in a { success, data } envelope — the real payload lives under data, so read that field before using the result. Non-2xx responses return { message, statusCode } instead.

Base URL

1https://api.kemegames.com/api/v1

1. Log the player in (auto-provisions on first login)

Call POST /portal/auth/login with the player's gameUid and a display username. The response contains a player bearer token (a JWT, valid for 7 days) and the resolved player object. Store the token and send it on every subsequent request.

POST /portal/auth/login

1curl -X POST https://api.kemegames.com/api/v1/portal/auth/login \
2  -H "Content-Type: application/json" \
3  -d '{
4    "gameUid": "player_12345",
5    "username": "GamerTag_XYZ"
6  }'
7
8# Response (unwrap "data"):
9# {
10#   "success": true,
11#   "data": {
12#     "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
13#     "player": { "id": "...", "username": "GamerTag_XYZ", "gameUid": "player_12345", ... }
14#   }
15# }

2. Create a support ticket

Call POST /portal/tickets with the token from step 1 in the Authorization header. Provide a subject (5–200 chars), a description (10–5000 chars), and your gameId. The optional category must be one of bug, billing, account, gameplay, or other.

POST /portal/tickets

1curl -X POST https://api.kemegames.com/api/v1/portal/tickets \
2  -H "Content-Type: application/json" \
3  -H "Authorization: Bearer <token>" \
4  -d '{
5    "subject": "Purchase failed",
6    "description": "My in-game purchase did not complete.",
7    "gameId": "game-marble-sort",
8    "category": "billing"
9  }'
10
11# Response (unwrap "data") → the created Ticket (HTTP 201):
12# { "success": true, "data": { "id": "...", "subject": "Purchase failed", "status": "open", ... } }

Calling the API from Unreal C++

Unreal ships an HTTP module out of the box, so no third-party dependency is required. Add "HTTP" and "Json" to your module's PublicDependencyModuleNames in Build.cs, then build a request like this. The pattern below performs the login and, on success, creates a ticket with the returned token.

Player login via the REST API

1#include "HttpModule.h"
2#include "Interfaces/IHttpRequest.h"
3#include "Interfaces/IHttpResponse.h"
4
5void SendKemeLogin(const FString& GameUid, const FString& Username)
6{
7    const FString Url = TEXT("https://api.kemegames.com/api/v1/portal/auth/login");
8
9    // Body: { "gameUid": "...", "username": "..." }
10    const FString Body = FString::Printf(
11        TEXT("{\"gameUid\":\"%s\",\"username\":\"%s\"}"),
12        *GameUid, *Username);
13
14    TSharedRef Request =
15        FHttpModule::Get().CreateRequest();
16    Request->SetURL(Url);
17    Request->SetVerb(TEXT("POST"));
18    Request->SetHeader(TEXT("Content-Type"), TEXT("application/json"));
19    Request->SetContentAsString(Body);
20
21    Request->OnProcessRequestComplete().BindLambda(
22        [](FHttpRequestPtr Req, FHttpResponsePtr Resp, bool bOk)
23    {
24        if (!bOk || !Resp.IsValid())
25        {
26            UE_LOG(LogTemp, Warning, TEXT("[Keme] Login request failed"));
27            return;
28        }
29
30        // Response is wrapped: { "success": true, "data": { "token": "...", "player": {...} } }
31        // Parse Resp->GetContentAsString() as JSON, read data.token, and store it
32        // for the Authorization: Bearer header on subsequent ticket requests.
33        UE_LOG(LogTemp, Log, TEXT("[Keme] Login response: %s"),
34               *Resp->GetContentAsString());
35    });
36
37    Request->ProcessRequest();
38}

Once you have the token, create a ticket by pointing the request at /portal/tickets, adding the Authorization: Bearer <token> header, and sending the ticket body.

Creating a ticket with the player token

1void SendKemeTicket(const FString& Token)
2{
3    const FString Url = TEXT("https://api.kemegames.com/api/v1/portal/tickets");
4
5    const FString Body = TEXT(
6        "{"
7        "\"subject\":\"Purchase failed\","
8        "\"description\":\"My in-game purchase did not complete.\","
9        "\"gameId\":\"game-marble-sort\","
10        "\"category\":\"billing\""
11        "}");
12
13    TSharedRef Request =
14        FHttpModule::Get().CreateRequest();
15    Request->SetURL(Url);
16    Request->SetVerb(TEXT("POST"));
17    Request->SetHeader(TEXT("Content-Type"), TEXT("application/json"));
18    Request->SetHeader(TEXT("Authorization"),
19                       FString::Printf(TEXT("Bearer %s"), *Token));
20    Request->SetContentAsString(Body);
21
22    Request->OnProcessRequestComplete().BindLambda(
23        [](FHttpRequestPtr Req, FHttpResponsePtr Resp, bool bOk)
24    {
25        if (bOk && Resp.IsValid())
26        {
27            // 201 Created. Unwrap "data" for the created Ticket (data.id, data.status, ...).
28            UE_LOG(LogTemp, Log, TEXT("[Keme] Ticket response: %s"),
29                   *Resp->GetContentAsString());
30        }
31    });
32
33    Request->ProcessRequest();
34}

Tip:From Blueprint-only projects you can make the exact same two requests using any HTTP request node (Unreal's built-in HTTP Blueprint library or a plugin such as VaRest). Build the JSON body, set the Content-Type and Authorization headers, and parse data from the response.

Warning:Treat the player token like any other credential — keep it in memory for the session and send it only over HTTPS. Do not log it or commit it to source control.

Full REST reference

The two calls above cover the core flow, but the player-portal API also supports listing and replying to tickets, rating a resolved ticket, and searching your knowledge base. See the complete endpoint list, request/response schemas, and error format in the REST API reference.

Note:This page will be replaced with native plugin documentation once the Unreal SDK is released. Until then, the REST integration above is the supported path for Unreal Engine games.

Last updated: July 18, 2026Edit this page

PreviousUnity SDK NextJavaScript SDK