Unreal Engine integration

Launcher Forge Auth allows an Unreal Engine game to validate whether it was started from an authorized Launcher Forge session. When a player starts the game from the launcher:

Launcher Forge generates a temporary credential for that launch.
The launcher starts the compiled executable and delivers the credential automatically.
The plugin internally retrieves the credential supplied by the launcher.
The plugin sends it to the validation endpoint.
The backend returns id, email, and valid.
The game continues or blocks access according to the result.

The temporary credential is not generated or entered manually. A real validation can only be tested after the compiled build is linked and started through Launcher Forge.

Understand launch tokens

Review the complete generation, delivery, and validation flow between the launcher and the game.

Validation flow

Direct plugin packages

Download Launcher Forge Auth for Unreal Engine

Discord DOWNLOAD PLUGIN category with the Unreal Engine channel

You can find the download link through our Discord server. Open the DOWNLOAD PLUGIN section and select the channel corresponding to your game engine.For Unreal Engine, open:

# unreal-engine

Always use the package that matches the exact Unreal Engine version used by your project.

Manual installation

Manual installation places the plugin directly inside the project.

Extract the package

Extract the LauncherAuthPlugin.zip package for your Unreal Engine version.

Open the project directory

Open the folder containing YourProject.uproject.

Create the Plugins directory

When it does not exist, create:

YourProject/
└── Plugins/

Copy the plugin

Extract the plugin into Plugins.Expected structure:

YourProject/
├── YourProject.uproject
└── Plugins/
    └── LauncherForgeAuth/
        ├── Binaries/
        ├── Content/
        ├── Intermediate/
        ├── Resources/
        ├── Source/
        └── LauncherForgeAuth.uplugin

Regenerate project files

Right-click YourProject.uproject and select:

Generate Visual Studio project files

Compile the project

Open YourProject.sln and compile the project again.

Verify the plugin

Open Unreal Engine and go to Edit → Plugins. Confirm that Launcher Forge Auth is enabled.

LauncherForgeAuth installed inside the project Plugins directory — Plugin structure inside the project Plugins directory

Plugin Browser showing Launcher Forge Auth enabled — Launcher Forge Auth enabled in Unreal Engine

C++ plugin binaries depend on the engine version. A package compiled for another version may require recompilation.

GameInstance configuration

The recommended place to start validation is a custom Blueprint based on GameInstance. This validates the connection before loading:

Player data.
Online menus.
Save games.
Protected features.
Systems that require a valid launcher connection.

1. Create and assign the GameInstance

Create the Blueprint

Create a Blueprint class based on GameInstance.

Name the class

For example:

BP_GameInstance

Open Project Settings

Go to Edit → Project Settings → Maps & Modes.

Select the class

Under Game Instance Class, select BP_GameInstance.

Project Settings showing BP_GameInstance as Game Instance Class — BP_GameInstance assigned in Maps & Modes

2. Configure Event Init

Inside the BP_GameInstance Event Graph, use:

Event Init → Delay 0.5 → Validate Launch Token

Add a 0.5-second delay before calling Validate Launch Token.In a packaged build, the subsystem or command-line arguments may not be ready during the first frame of Init.

Blueprint showing the initialization and validation flow — Event Init, Delay 0.5, and Validate Launch Token

Validate Launch Token node

The main plugin node is:

Validate Launch Token

Input

Input	Description
Backend Url	Complete URL of the endpoint that validates the launch token.

Endpoint used by the source document:

https://backend.launcherforge.io/api/v1/games/auth/validate-launch-token

Output delegates

Delegate	Behavior
On Success	Runs when the backend validates the token successfully.
On Failed	Runs when the token is missing, expired, invalid, or the HTTP request fails.

Blueprint showing Validate Launch Token and authenticated data — Main node and authenticated data

On Success

Use On Success to:

Confirm that Valid is true.
Store or use Id and Email.
Continue to the main menu.
Load account-specific data.
Enable protected systems.
Allow access to the game.

On Failed

Use On Failed to:

Display a controlled error.
Block access.
Ask the player to start the game from Launcher Forge.
Return to an initial screen.
Close the game gracefully.

Complete Blueprint flow with On Success and On Failed — Complete Blueprint flow with success and failure branches

Automatic validation

Launcher Forge generates and delivers the temporary credential as part of the normal game launch. The developer must not:

Create credentials manually for testing.
Store them in the project.
Hardcode them in Blueprint or C++.
Store them in configuration files.
Display them in the user interface.
Print complete values in production logs.

The plugin receives the credential automatically when a linked build is started through Launcher Forge. Opening the game in the editor or running the .exe directly does not reproduce a real validation.

Internal plugin request

The plugin internally sends the credential to the backend using the contract expected by the validation endpoint:

{
  "token": "TEMPORARY_CREDENTIAL"
}

Do not build this request from Blueprint or ask the player to enter a token.

Expected response

{
  "success": true,
  "data": {
    "id": "authenticated-id",
    "email": "player@example.com",
    "valid": true
  }
}

boolean

Indicates that the backend processed validation successfully.

string

Authenticated account or session identifier.

string

Email address associated with the authenticated session.

boolean

Confirms that the backend accepted the launch token.

The plugin currently exposes:

Id
Email
Valid

Initial test inside the editor

Before packaging and linking the game to a launcher, you can confirm that the integration initialized by reviewing the Output Log. In this scenario, it is correct to see:

An empty token.
Length: 0.
A warning that the connection initialized but requires a valid token.

Test widget showing an invalid validation result — Invalid result before starting through the launcher

Output Log showing Length 0 and the required-token warning — Output Log with an empty token in the editor

Expected log example:

[LauncherForgeAuth] Launch token found. Length: 0
[LauncherForgeAuth] Request method: POST
[LauncherForgeAuth] HTTP request started.
[LauncherForgeAuth] Connection was initialized, but it requires a valid token.

This confirms that the plugin and connection initialized. It does not confirm valid authentication because the editor did not receive a launcher-generated token.

Test with a linked build

Complete validation must be tested with:

A packaged game.
A published build.
The game linked to the launcher.
The executable started from Launcher Forge.
A launch token generated during that startup.

When validation succeeds:

Valid is true.
Email contains the authenticated email.
Id contains the returned identifier.
On Success runs.

Test widget showing Valid, Email, and Id — Authenticated game after launching through Launcher Forge

The connection is valid when the game reads the launcher-generated token, the backend accepts it, and the plugin returns through On Success.

C++ usage

C++ projects can use the public plugin classes.

Main classes

Class	Responsibility
`UValidateLaunchTokenAsync`	Validates the token against the backend. This class powers the Blueprint node.
`ULauncherForgeAuthSubsystem`	Retrieves the temporary credential delivered by Launcher Forge and stores the authenticated user after successful validation.
`FLauncherForgeAuthUser`	Contains `Id`, `Email`, and `Valid`.

Recommended C++ flow

GameInstance::Init()
→ Delay 0.5 seconds
→ Validate Launch Token
→ On Success: read FLauncherForgeAuthUser
→ On Failed: handle the authentication error

Keep the 0.5-second delay in C++ as well. This avoids early initialization problems in packaged builds.

`.cpp` example

#include "MyGameInstance.h"
#include "TimerManager.h"
#include "ValidateLaunchTokenAsync.h"
#include "LauncherForgeAuthTypes.h"

void UMyGameInstance::Init()
{
    Super::Init();

    GetWorld()->GetTimerManager().SetTimer(
        LauncherAuthTimerHandle,
        this,
        &UMyGameInstance::ValidateLauncherSession,
        0.5f,
        false
    );
}

void UMyGameInstance::ValidateLauncherSession()
{
    const FString BackendUrl =
        TEXT("https://your-api.com/api/v1/games/auth/validate-launch-token");

    UValidateLaunchTokenAsync* AuthNode =
        UValidateLaunchTokenAsync::ValidateLaunchToken(
            this,
            BackendUrl
        );

    if (!AuthNode)
    {
        UE_LOG(
            LogTemp,
            Error,
            TEXT("[LauncherForgeAuth] Failed to create validation node.")
        );
        return;
    }

    AuthNode->OnSuccess.AddDynamic(
        this,
        &UMyGameInstance::HandleLauncherAuthSuccess
    );

    AuthNode->OnFailed.AddDynamic(
        this,
        &UMyGameInstance::HandleLauncherAuthFailed
    );

    AuthNode->Activate();
}

void UMyGameInstance::HandleLauncherAuthSuccess(
    FLauncherForgeAuthUser User
)
{
    UE_LOG(
        LogTemp,
        Log,
        TEXT("[LauncherForgeAuth] Authenticated user: %s"),
        *User.Email
    );
}

void UMyGameInstance::HandleLauncherAuthFailed(
    FString ErrorMessage
)
{
    UE_LOG(
        LogTemp,
        Error,
        TEXT("[LauncherForgeAuth] Authentication failed: %s"),
        *ErrorMessage
    );
}

`.h` excerpt

#include "LauncherForgeAuthTypes.h"

FTimerHandle LauncherAuthTimerHandle;

UFUNCTION()
void ValidateLauncherSession();

UFUNCTION()
void HandleLauncherAuthSuccess(
    FLauncherForgeAuthUser User
);

UFUNCTION()
void HandleLauncherAuthFailed(
    FString ErrorMessage
);

The code above reproduces the source document’s example. Integrate it into the real declaration of your UGameInstance class and the appropriate source files.

GameLauncherClient sample project

The free GameLauncherClient sample project targets Unreal Engine 5.5 and includes:

The plugin.
A configured GameInstance.
The validation flow.
A starting point for testing.

Download GameLauncherClient for UE 5.5

Discord DOWNLOAD TEMPLATES category with the GameLauncherClient sample-project channel

You can find the download link through our Discord server. Open the DOWNLOAD TEMPLATES section and select the channel corresponding to your game engine.For the Unreal Engine sample project, open:

# game-launcher-cliente-ue

The project targets Unreal Engine 5.5. Later versions may require recompilation.The plugin is free and must not be commercialized or resold separately.

Troubleshooting

The node does not appear

Confirm that the plugin exists under Plugins, is enabled under Edit → Plugins, and was compiled for the correct engine version.

The subsystem is unavailable

Start validation from GameInstance and keep the 0.5-second delay.

Length is 0 inside the editor

This is expected before the game is started through Launcher Forge. Confirm that the initialized-connection warning is also present.

On Failed runs in the packaged build

Confirm that the build is linked, the launcher uses the correct executable, and Backend Url points to the validation endpoint.

The backend rejects validation

Close the game and start it again through Launcher Forge to create a new temporary session.Also confirm that:

The build is linked to the launcher.
The launcher uses the correct executable.
Backend Url points to the validation endpoint.
The test is not being performed from the editor or by running the .exe directly.

The plugin was compiled for another engine version

Use a package for the current engine version or recompile the plugin with the project.

Verification checklist

The plugin is installed under Plugins.
Launcher Forge Auth is enabled.
The project was recompiled.
BP_GameInstance is assigned under Maps & Modes.
Event Init uses a 0.5-second delay.
Validate Launch Token uses the correct URL.
On Success continues only when Valid is true.
On Failed blocks access in a controlled way.
No credential is manually created, entered, or reused.
The plugin performs the validation request internally.
The final test was completed from a linked build started through Launcher Forge.

Launch tokens

Understand the complete validation contract.

Publish your first build

Publish the build through the interactive CLI.

Test your launcher

Verify installation, download, and startup through Launcher Forge.

​Unreal Engine integration

Understand launch tokens

​Validation flow

​Direct plugin packages

Download Launcher Forge Auth for Unreal Engine

​Manual installation

​GameInstance configuration

​1. Create and assign the GameInstance

​2. Configure Event Init

​Validate Launch Token node

​Input

​Output delegates

​On Success

​On Failed

​Automatic validation

​Internal plugin request

​Expected response

​Initial test inside the editor

​Test with a linked build

​C++ usage

​Main classes

​Recommended C++ flow

​.cpp example

​.h excerpt

​GameLauncherClient sample project

Download GameLauncherClient for UE 5.5

​Troubleshooting

​Verification checklist

​Related guides

Launch tokens

Publish your first build

Test your launcher

Unreal Engine integration

Validation flow

Direct plugin packages

Manual installation

GameInstance configuration

1. Create and assign the GameInstance

2. Configure Event Init

Validate Launch Token node

Input

Output delegates

On Success

On Failed

Automatic validation

Internal plugin request

Expected response

Initial test inside the editor

Test with a linked build

C++ usage

Main classes

Recommended C++ flow

`.cpp` example

`.h` excerpt

GameLauncherClient sample project

Troubleshooting

Verification checklist

Related guides