Unity integration

LauncherForge Launch Authentication validates whether a Unity build was started from an authorized Launcher Forge session. The integration can be used to restrict access to the game or specific features until the backend confirms the connection between the launcher and the executable.

Understand launch tokens

Review how Launcher Forge automatically generates and validates the temporary credential used when starting the game.

The temporary credential is generated and delivered automatically by Launcher Forge. It must not be entered manually or used as a testing method.Pressing Play inside the Unity Editor or running the build directly does not reproduce a real authentication flow.

How it works

Requirements

Before you begin, confirm that:

The game exists and is published in Launcher Forge.
The game is linked to the launcher.
You are using a Unity version compatible with the package.
The project can use local packages.
You know the validation endpoint URL.
The final test will be performed with a published build started through Launcher Forge.

Unity installation

Download LauncherForge Launch Authentication 1.0.2

Discord DOWNLOAD PLUGIN category with channels for Unreal Engine, Unity, and Godot

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 this integration, open:

# unity

Install the package

The package can be installed by copying it into the project or by selecting its package.json file through Unity Package Manager.

Copy into Packages
Package Manager

Extract the archive

Extract:

LauncherForge_LauncherAuth_Unity_1.0.2.zip

Rename the folder

The extracted folder is named:

com.launcherforge.launcherauth-1.0.2

Rename it exactly to:

com.launcherforge.launcherauth

Copy the package into the project

Place the folder inside Packages:

YourUnityProject/
├── Assets/
├── Packages/
│   └── com.launcherforge.launcherauth/
├── ProjectSettings/
└── UserSettings/

Verify the structure

The package must contain:

Packages/
└── com.launcherforge.launcherauth/
    ├── package.json
    ├── README.md
    ├── CHANGELOG.md
    └── Runtime/
        ├── LauncherAuthBootstrap.cs
        ├── LauncherAuthModels.cs
        ├── LauncherAuthSession.cs
        ├── LauncherAuthSettings.cs
        ├── LaunchTokenReader.cs
        └── LauncherForge.LauncherAuth.asmdef

File Explorer showing com.launcherforge.launcherauth inside Packages — Package copied into the Packages folder

Open Package Manager

In Unity, open:

Window → Package Manager

Select Install package from disk

Select the + button, then choose:

Install package from disk

Select package.json

Open:

com.launcherforge.launcherauth/package.json

Confirm the installation

The package should appear in Package Manager as:

LauncherForge Launch Authentication 1.0.2

Unity Package Manager showing LauncherForge Launch Authentication 1.0.2 — LauncherForge Launch Authentication installed in Package Manager

Create the configuration

The package automatically loads its configuration from Resources.

Create the Resources folder

Inside Assets, create:

Assets/Resources/

Create Launcher Auth Settings

Inside Resources, use:

Create → LauncherForge → Launcher Auth Settings

Use the exact name

The asset must be named:

LauncherAuthSettings

Verify the final path

The asset must be located at:

Assets/Resources/LauncherAuthSettings.asset

The name and path are required because the package loads the asset with:

Resources.Load<LauncherAuthSettings>(
    "LauncherAuthSettings"
);

If you rename the asset or move it outside Assets/Resources, the package will not be able to load the configuration automatically.

Configure the backend

Select:

Assets/Resources/LauncherAuthSettings.asset

The Inspector contains:

string

Full URL of the validation endpoint.

float

Time the package waits before starting validation.

float

Maximum amount of time allowed for the HTTP request.

Recommended configuration:

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

Startup Delay Seconds:
0.5

Timeout Seconds:
10

The internal request uses the contract expected by the backend:

{
  "token": "TEMPORARY_CREDENTIAL"
}

The package builds this request automatically. You do not need to send it from another script or ask the player to enter a credential.

Automatic initialization

Do not manually add the package to a GameObject. When the game starts, the package automatically creates:

[LauncherAuth]

Internally, it uses:

RuntimeInitializeOnLoadMethod

The object remains active when changing scenes through:

DontDestroyOnLoad

The internal flow is:

Available states

Import the namespace:

using LauncherForge.LauncherAuth;

The current state is available through:

LauncherAuthSession.State

State	Description
`LauncherAuthState.NotStarted`	Initialization has not started yet.
`LauncherAuthState.WaitingForStartup`	The package is waiting for the configured delay.
`LauncherAuthState.ReadingToken`	The package is retrieving the launch credential.
`LauncherAuthState.Validating`	The backend is validating the request.
`LauncherAuthState.Authenticated`	Authentication completed successfully.
`LauncherAuthState.Failed`	Authentication could not be completed.

Successful authentication

After successful validation, the user is available through:

LauncherAuthSession.User

Available fields:

LauncherAuthSession.User.id
LauncherAuthSession.User.email
LauncherAuthSession.User.valid

The identifier is a string:

string userId = LauncherAuthSession.User.id;

string

Authenticated identifier returned by the backend.

string

Email associated with the validated session.

boolean

Confirms that the credential was accepted.

Unity project showing Launcher Auth Access Granted — Successful authentication in a build started through Launcher Forge

Check the current result

You can inspect the session state from any script that imports the namespace.

using LauncherForge.LauncherAuth;
using UnityEngine;

public sealed class LauncherAuthExample : MonoBehaviour
{
    private void Start()
    {
        if (LauncherAuthSession.IsAuthenticated)
        {
            LauncherAuthenticatedUser user =
                LauncherAuthSession.User;

            Debug.Log(
                $"Authenticated user: {user.id}"
            );

            Debug.Log(
                $"Email: {user.email}"
            );

            Debug.Log(
                $"Valid: {user.valid}"
            );
        }
    }
}

Relying only on an if executed once in Start is not recommended because validation may still be in progress. Use the package events to react immediately.

Failed authentication

There is no property named:

LauncherAuthSession.Failed

The correct check is:

if (
    LauncherAuthSession.State ==
    LauncherAuthState.Failed
)
{
    string error =
        LauncherAuthSession.LastError;

    Debug.LogError(error);
}

Combined example:

if (LauncherAuthSession.IsAuthenticated)
{
    LauncherAuthenticatedUser user =
        LauncherAuthSession.User;

    // The game decides how to continue.
}
else if (
    LauncherAuthSession.State ==
    LauncherAuthState.Failed
)
{
    string error =
        LauncherAuthSession.LastError;

    // The game decides how to display the error.
}

Unity project showing Launcher Auth Access Denied — Expected result when the build was not started through Launcher Forge

Use authentication events

This is the recommended approach for a main menu or controller that must react as soon as validation finishes.

using LauncherForge.LauncherAuth;
using UnityEngine;

public sealed class LauncherAuthMenuController : MonoBehaviour
{
    private void OnEnable()
    {
        LauncherAuthSession.AuthenticationSucceeded +=
            HandleAuthenticationSucceeded;

        LauncherAuthSession.AuthenticationFailed +=
            HandleAuthenticationFailed;

        EvaluateCurrentState();
    }

    private void OnDisable()
    {
        LauncherAuthSession.AuthenticationSucceeded -=
            HandleAuthenticationSucceeded;

        LauncherAuthSession.AuthenticationFailed -=
            HandleAuthenticationFailed;
    }

    private void EvaluateCurrentState()
    {
        if (LauncherAuthSession.IsAuthenticated)
        {
            HandleAuthenticationSucceeded(
                LauncherAuthSession.User
            );
            return;
        }

        if (
            LauncherAuthSession.State ==
            LauncherAuthState.Failed
        )
        {
            HandleAuthenticationFailed(
                LauncherAuthSession.LastError
            );
        }
    }

    private static void HandleAuthenticationSucceeded(
        LauncherAuthenticatedUser user)
    {
        Debug.Log(
            $"Authentication succeeded. " +
            $"User ID: {user.id}"
        );

        // The game decides what to do:
        // - enable Play
        // - load the menu
        // - enable online features
        // - load another scene
    }

    private static void HandleAuthenticationFailed(
        string error)
    {
        Debug.LogError(
            $"Authentication failed: {error}"
        );

        // The game decides what to do:
        // - display an error
        // - disable online options
        // - display a close button
        // - return to the launcher
    }
}

EvaluateCurrentState() is important because authentication may have finished before the object subscribed to the events.

Behavior inside the Unity Editor

When you press Play directly in the editor, the expected result is an access-denied state. This does not indicate a package error. It confirms that:

Automatic initialization worked.
The package attempted to retrieve the launch credential.
The editor did not receive a credential generated by Launcher Forge.
LauncherAuthSession.State changed to LauncherAuthState.Failed.
The error message became available through LauncherAuthSession.LastError.

The package does not contain a TokenOverride for the Editor. Real authentication cannot be tested through the editor’s Play button.

Test real authentication

To verify the complete integration:

Create a Unity build

Compile the project with all files required to run it outside the editor.

Publish the build

Upload the version through Launcher Forge CLI.

Link the game

Confirm that the published game is associated with the correct launcher.

Install the game from the launcher

Use a player account with access to the game.

Start the build through Launcher Forge

The launcher will automatically generate and deliver the temporary credential.

Verify the result

The session should become authenticated and the AuthenticationSucceeded event should run.

When the backend responds successfully:

{
  "success": true,
  "data": {
    "id": "12345",
    "email": "user@example.com",
    "valid": true
  }
}

The package sets:

LauncherAuthSession.IsAuthenticated == true

LauncherAuthSession.State ==
    LauncherAuthState.Authenticated

The user is available through:

LauncherAuthSession.User

Failed authentication result

Validation may fail because of:

Missing credential.
Invalid credential.
Expired credential.
Backend unavailable.
Timeout.
Invalid JSON response.
valid == false.
Empty or missing id.

The package sets:

LauncherAuthSession.IsAuthenticated == false

LauncherAuthSession.State ==
    LauncherAuthState.Failed

The message is available through:

LauncherAuthSession.LastError

The package does not close the game automatically. Your project decides whether to display an error, disable features, offer a close action, or continue with limited capabilities.

Troubleshooting

The package does not appear in Package Manager

Confirm that:

The folder is named com.launcherforge.launcherauth.
package.json is located at the package root.
You selected the correct file through Install package from disk.
The Unity version is compatible.

LauncherAuthSettings does not load

Confirm the exact path and name:

Assets/Resources/LauncherAuthSettings.asset

The asset must be named exactly LauncherAuthSettings.

The session remains Failed inside the Editor

This is the expected result. The editor does not receive a temporary credential from Launcher Forge, and there is no override for simulating one.Perform the final test with a published, linked build started through the launcher.

The backend does not respond

Review:

Backend Url.
Backend availability.
HTTPS certificate.
Timeout Seconds value.
Build connectivity.

Authentication finishes before the menu listens to the events

The build opens but does not authenticate

Confirm that:

The build was published through the CLI.
The game is linked to the correct launcher.
The correct main executable was configured.
The build was started through Launcher Forge.
The configuration asset is included in Resources.

License and sample project

According to the integration document, the package is provided free of charge and may not be commercialized or resold.

Download UnityThirdPersonAuthTest

Discord DOWNLOAD TEMPLATES category with sample projects for Unreal Engine, Unity, and Godot

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 Unity sample project, open:

# thid-person-auth-test-unity

UnityThirdPersonAuthTest includes the package and a prepared integration for Unity 6 or another compatible version.

Verification checklist

The package is located at Packages/com.launcherforge.launcherauth.
Package Manager displays LauncherForge Launch Authentication.
Assets/Resources/LauncherAuthSettings.asset exists.
Backend Url contains the full endpoint.
Startup Delay Seconds is set to 0.5.
Timeout Seconds is set to 10.
You did not add a manual bootstrap component to a GameObject.
The code imports LauncherForge.LauncherAuth.
The menu uses events or evaluates the current state.
The project handles both Authenticated and Failed.
You do not attempt to enter a credential manually.
The final test is performed with a linked build started through Launcher Forge.

The integration is ready when a build started through Launcher Forge triggers AuthenticationSucceeded, exposes id, email, and valid, and your game correctly handles the Failed state.

Launch tokens

Understand automatic validation between the launcher and the game.

Publish your first build

Publish the Unity build through the interactive CLI.

Test your launcher

Verify installation, download, and startup through Launcher Forge.

Introduction

Getting Started

Launcher Configuration

Releases

Launcher Forge CLI

Player Authentication

Engine Integrations

Workspace and Account

Resources

Unity

Unity integration

Understand launch tokens

How it works

Requirements

Unity installation

Download LauncherForge Launch Authentication 1.0.2

Install the package

Create the configuration

Configure the backend

Automatic initialization

Available states

Successful authentication

Check the current result

Failed authentication

Use authentication events

Behavior inside the Unity Editor

Test real authentication

Failed authentication result

Troubleshooting

License and sample project

Download UnityThirdPersonAuthTest

Verification checklist

Launch tokens

Publish your first build

Test your launcher

​Unity integration

Understand launch tokens

​How it works

​Requirements

​Unity installation

Download LauncherForge Launch Authentication 1.0.2

​Install the package

​Create the configuration

​Configure the backend

​Automatic initialization

​Available states

​Successful authentication

​Check the current result

​Failed authentication

​Use authentication events

​Behavior inside the Unity Editor

​Test real authentication

​Failed authentication result

​Troubleshooting

​License and sample project

Download UnityThirdPersonAuthTest

​Verification checklist

​Related guides

Launch tokens

Publish your first build

Test your launcher

Unity integration

How it works

Requirements

Unity installation

Install the package

Create the configuration

Configure the backend

Automatic initialization

Available states

Successful authentication

Check the current result

Failed authentication

Use authentication events

Behavior inside the Unity Editor

Test real authentication

Failed authentication result

Troubleshooting

License and sample project

Verification checklist

Related guides