Documentation

Support

Authentication for Unreal Engine

Authentication overview

Authentication for Unreal Engine

C++ integration

Learn how to implement authentication using C++ in Unreal Engine.
Read time 6 minutesLast updated 2 hours ago
The following section shows how to integrate with the Authentication SDK using Unreal Engine Subsystems. The Blueprint API provides the Authentication Subsystem to expose this functionality.

Add the Authentication SDK as a dependency

Before continuing, add 
Authentication
as a public dependency of your module, then include the plugin header files in your classes. Add 
Authentication
as a dependency of your module to your Unreal project build file: 
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Authentication" });
Include the plugin header files you wish to access in your own classes: 
#include "AuthenticationSubsystem.h"

Authentication Subsystem

The Authentication Subsystem contains the interface to communicate with Unity Authentication servers, hold player profile information, and load/unload player preferences from local storage. It’s responsible for handling the authentication lifecycle and storing important authentication information for your project. You can access the Authentication Subsystem by obtaining a reference from a UGameInstance. 
UWorld* GameWorld = GetWorld();UGameInstance* GameInstance = GameWorld->GetGameInstance();UAuthenticationSubsystem* AuthenticationSubsystem = GameInstance->GetSubsystem<UAuthenticationSubsystem>();

SignInAnonymously

Use the SignInAnonymously() method to anonymously authenticate. This is a quick way to authenticate without any user information, and requires no interaction with external providers. If successful, this populates the current player profile with the retrieved credentials returned from the Unity Authentication servers. SignInAnonymously() takes an 
FAuthenticationSignInOptions
 struct as a parameter that changes the way a sign-in is performed. See the Unity API services documentation page for more information about these parameters. The response from the SDK can be handled in a response handler which needs to take in an 
FAuthenticationResponse
. 
// Create sign-in options bodyFAuthenticationSignInOptions SignInOptions;SignInOptions.bCreateAccount = true;SignInOptions.Nonce = TEXT("abc123");AuthenticationSubsystem->SignInAnonymously(SignInOptions, THandler<FAuthenticationResponse>::CreateLambda([this](https://docs.unity.com/ugs/en-us/manual/authentication/manual/unreal-engine-sdk/%0AFAuthenticationResponse%20Response){	// Your response logic here}));

GetUserInfo

Use the GetUserInfo() method to retrieve information about the currently authenticated user. This includes their user Id, authentication timestamps, and any external Identity providers that are linked to their session. The response from the SDK can be handled in a response handler which needs to take in an 
FAuthenticationUserResponse
. 
AuthenticationSubsystem->GetUserInfo(THandler<FAuthenticationUserResponse>::CreateLambda([this](https://docs.unity.com/ugs/en-us/manual/authentication/manual/unreal-engine-sdk/%0AFAuthenticationUserResponse%20Response){	// Your response logic here}));

DeleteUser

Use the DeleteUser() method to delete all information related to the currently authenticated player. This method also signs out the player, and deletes all player preferences and profiles connected to the player. The response from the SDK can be handled in a response handler which needs to take in a 
bool
: its value is 
true
in case of successful deletion and 
false
otherwise. 
AuthenticationSubsystem->DeleteUser(THandler<bool>::CreateLambda([this](https://docs.unity.com/ugs/en-us/manual/authentication/manual/unreal-engine-sdk/bool%20bResponse){	// Your response logic here}));

RegisterStateChangedCallback

Use the RegisterStateChangedCallback() method to assign a callback function that invokes upon the state of the subsystem changing. For instance, the assigned function executes when a player has successfully authenticated and the subsystem state has changed to 
Authorized
. The response from the SDK can be handled in a response handler which needs to take in an 
AuthenticationStateChangedResponse
. 
AuthenticationSubsystem->RegisterStateChangedCallback(THandler<AuthenticationStateChangedResponse>::CreateLambda([this](https://docs.unity.com/ugs/en-us/manual/authentication/manual/unreal-engine-sdk/%0AAuthenticationStateChangedResponse%20Response){	// Your response logic here}));

SignOut

Use the SignOut() method to sign-out of the currently authenticated player profile. This removes the current player profile and switches to the default profile. This method also has an optional parameter to remove any stored credentials associated with this player. 
AuthenticationSubsystem->SignOut(true); // Clear player credentials

SwitchProfile

Use the SwitchProfile() method to switch to or create a player profile. 
FString NewProfileName = FString(TEXT("new_profile_123"));AuthenticationSubsystem->SwitchProfile(NewProfileName);

ProfileExists

Use the ProfileExists() method to check if a given profile exists in the current session. 
FString ProfileToCheckFor = FString(TEXT("new_profile_123"));bool bExists = AuthenticationSubsystem->ProfileExists(ProfileToCheckFor);

GetCurrentProfileName

Use the GetCurrentProfileName() method to retrieve the name of the current player profile. 
FString ProfileName = AuthenticationSubsystem->GetCurrentProfileName();

GetProfileNames

Use the GetCurrentProfileName() method to retrieve a list of all player profile names being used in the current session. 
TArray<FString> ProfileNames = AuthenticationSubsystem->GetProfileNames();

RegisterProfileChangedCallback

Use the RegisterProfileChangedCallback() method to assign a callback function that invokes upon the player profile changing. For instance, the assigned function executes when SwitchProfile has executed successfully. The response from the SDK can be handled in a response handler which needs to take in an AuthenticationPlayerProfileChangedResponse. 
AuthenticationSubsystem->RegisterPlayerProfileChangedCallback(THandler<AuthenticationPlayerProfileChangedResponse>::CreateLambda([this](https://docs.unity.com/ugs/en-us/manual/authentication/manual/unreal-engine-sdk/%0AAuthenticationPlayerProfileChangedResponse%20Response){	// Your response logic here}));

RegisterProfileDeletedCallback

Use the RegisterProfileChangedCallback() method to assign a callback function that invokes upon a player profile getting removed from the current session. For instance, the assigned function executes when SignOut has executed successfully. The response from the SDK can be handled in a response handler which needs to take in an AuthenticationPlayerProfileChangedResponse. 
AuthenticationSubsystem->RegisterPlayerProfileChangedCallback(THandler<AuthenticationPlayerProfileChangedResponse>::CreateLambda([this](https://docs.unity.com/ugs/en-us/manual/authentication/manual/unreal-engine-sdk/%0AAuthenticationPlayerProfileChangedResponse%20Response){	// Your response logic here}));

IsSignedIn

Use the IsSignedIn() method to check whether the current player profile is signed-in. Being “Signed-In” is defined as being either Authorized or Expired. 
bool bSignedIn = AuthenticationSubsystem->IsSignedIn();

IsAnonymous

Use the IsAnonymous() method to check whether the current player profile is signed-in anonymously. This should return true after executing SignInAnonymously successfully. 
bool bAnonymous = AuthenticationSubsystem->IsAnonymous();

IsAuthorized

Use the IsAuthorized() method to check whether the current player profile is signed-in and currently authorized. This should return true after executing any sign-in method successfully while the expiration time has not yet passed. 
bool bAuthorized = AuthenticationSubsystem->IsAuthorized();

IsExpired

Use the IsExpired() method to check whether the current player profile’s session has expired. This should return true when the expiry time returned from a successful sign-in response has passed. 
bool bExpired = AuthenticationSubsystem->IsExpired();

SessionTokenExists

Use the SessionTokenExists() method to check whether a session token exists in player preferences for the current player profile. 
bool bTokenExists = AuthenticationSubsystem->SessionTokenExists();

GetUnityProjectId

Use the GetUnityProjectId() method to retrieve the Unity Project Id associated with the current authentication session. 
FGuid ProjectId = AuthenticationSubsystem->GetUnityProjectId();

GetUnityEnvironmentName

Use the GetUnityEnvironmentName() method to retrieve the name of the Unity Environment Id associated with the current authentication session. 
FString EnvironmentId = AuthenticationSubsystem->GetUnityEnvironmentName();

GetAccessToken

Use the GetAccessToken() method to retrieve the access token for the current session. If none exists, this returns an empty string. 
FString AccessToken = AuthenticationSubsystem->GetAccessToken();

GetSessionToken

Use the GetSessionToken() method to retrieve the session token for the current session. If none exists, this returns an empty string. 
FString SessionToken = AuthenticationSubsystem->GetSessionToken();

GetUserId

Use the GetUserId() method to retrieve the user Id for the current session. If none exists, this returns an empty string. 
FString UserId = AuthenticationSubsystem->GetUserId();

GetState

Use the GetState() method to retrieve the current state of the authentication session. 
EAuthenticationState UserId = AuthenticationSubsystem->GetUserId();

SetUnityProjectId

Use the SetUnityProjectId() method to set the Unity Project Id for the current authentication session. This overrides the Unity Project Id configured in Project Settings. 
FGuid NewProjectId = FGuid(TEXT("00000000-1234-1234-000000000000"));AuthenticationSubsystem->SetUnityProjectId(NewProjectId);

SetUnityEnvironmentName

Use the SetUnityEnvironmentName() method to set the Unity Environment name for the current authentication session. This overrides the Unity Environment name configured in Project Settings. 
FString NewEnvironmentName = FString(TEXT("testenv2"));AuthenticationSubsystem->SetUnityEnvironmentName(NewEnvironmentName );