Unity Authentication

https://docs.unity.com/en-us/authentication
Admin
Implement secure player authentication with anonymous, platform-specific, and custom sign-in...
Tokens:74,859
Snippets:757
Trust Score:10
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Sign in with Unity Player Accounts and Unity Authentication

Source: https://docs.unity.com/en-us/authentication/unity-player-accounts

Complete Unity C# example for signing in a returning player or creating a new player using Unity Player Accounts and Unity Authentication. It initializes services, registers the SignedIn event, starts the browser-based sign-in flow, and then signs in to Unity Authentication with the access token. Includes error handling for PlayerAccountsException, AuthenticationException, and RequestFailedException.

```csharp
async void Start()
{
    await UnityServices.InitializeAsync();

    // Register the Unity Player Accounts sign-in event handler after services initialization.
    PlayerAccountService.Instance.SignedIn += SignInWithUnityAuth;
}

// Call this from a button or other application-specific trigger to begin the sign-in flow.
async void StartPlayerAccountsSignInAsync()
{
    if (PlayerAccountService.Instance.IsSignedIn)
    {
        // If the player is already signed into Unity Player Accounts, proceed directly to the Unity Authentication sign-in.
        SignInWithUnityAuth();
        return;
    }

    try
    {
        // This will open the system browser and prompt the user to sign in to Unity Player Accounts
        await PlayerAccountService.Instance.StartSignInAsync();
    }
    catch (PlayerAccountsException ex) {
        // Compare error code to PlayerAccountsErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}

 async void SignInWithUnityAuth()
{
    try
    {
        await AuthenticationService.Instance.SignInWithUnityAsync(PlayerAccountService.Instance.AccessToken);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### Steam SDK setup paths

Source: https://docs.unity.com/en-us/authentication/platform-signin/steam

Folder and file references for Steam setup: copy the SteamWorks.Net SDK into the Assets/ folder and open steam_appid.txt in the project root to replace 480 with your App ID.

```text
Assets/
```

```text
steam_appid.txt
```

--------------------------------

### Initialize Unity Services SDK with UnityServices.InitializeAsync

Source: https://docs.unity.com/en-us/authentication/get-started

Initializes all Unity Services SDKs included in the project. Call this before using Authentication. The example catches and logs any exception thrown during initialization.

```csharp
using System;
using Unity.Services.Core;
using UnityEngine;

public class InitializationExample : MonoBehaviour
{
	async void Awake()
	{
		try
		{
			await UnityServices.InitializeAsync();
		}
		catch (Exception e)
		{
			Debug.LogException(e);
		}
	}
}
```

--------------------------------

### Sign in with Apple using SignInWithAppleAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/apple

Use this method to sign in an existing player or create a new player with Apple credentials. It does not consider the cached player and replaces it. The example catches AuthenticationException and RequestFailedException for error handling.

```csharp
async Task SignInWithAppleAsync(string idToken)
{
    try
    {
        await AuthenticationService.Instance.SignInWithAppleAsync(idToken);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### Install com.unity.ads.ios-support package

Source: https://docs.unity.com/en-us/authentication/platform-signin/facebook

The package name to install from the Unity Editor Package Manager for iOS support, including ATT consent handling.

```text
com.unity.ads.ios-support
```

--------------------------------

### AuthenticationClient sign-in callback

Source: https://docs.unity.com/en-us/authentication/uas-native-sdk

Example of an AuthenticationClient and sign-in callback. Sets environment name and project ID, signs in anonymously, clears the session token to force a new PlayerId on the next anonymous sign-in, and refreshes the token.

```cpp
unity::uaslib::AuthenticationClient client;
    client.SetEnvironmentName(UNITY_ENVIRONMENT_NAME);
    client.SetProjectId(UNITY_PROJECT_ID);

    Unity::Authentication::AuthenticationSignInCallback cb;
    cb = [](const unity::uaslib::AuthenticationSignInResponse &response) {
        std::cout << "Authentication Sign In Response:\n";
        std::cout << "Token: " << response.Token << "\n";
        std::cout << "PlayerId: " << response.PlayerId << "\n";
        std::cout << "ExpiresIn: " << response.ExpiresIn << "\n";
    };

    client.SignInAnonymously(cb);

    //Running ClearSessionToken prior to a another SignInAnonymously
    //will result in a new PlayerId
    client.ClearSessionToken();
    client.SignInAnonymously(cb);

    client.RefreshToken(cb);
```

--------------------------------

### AuthenticationClient sign-in and token refresh example

Source: https://docs.unity.com/en-us/authentication/uas-native-sdk

Sets up an AuthenticationClient with environment and project ID, defines a sign-in callback that prints the token, player ID, and expiry, then performs SignInAnonymously, clears the session token, signs in again, and refreshes the token. ClearSessionToken before another SignInAnonymously results in a new PlayerId.

```C++
unity::uaslib::AuthenticationClient client;
    client.SetEnvironmentName(UNITY_ENVIRONMENT_NAME);
    client.SetProjectId(UNITY_PROJECT_ID);

    Unity::Authentication::AuthenticationSignInCallback cb;
    cb = [](const unity::uaslib::AuthenticationSignInResponse &response) {
        std::cout << "Authentication Sign In Response:\n";
        std::cout << "Token: " << response.Token << "\n";
        std::cout << "PlayerId: " << response.PlayerId << "\n";
        std::cout << "ExpiresIn: " << response.ExpiresIn << "\n";
    };

    client.SignInAnonymously(cb);

    //Running ClearSessionToken prior to another SignInAnonymously
    //will result in a new PlayerId
    client.ClearSessionToken();
    client.SignInAnonymously(cb);

    client.RefreshToken(cb);

```

--------------------------------

### Sign in with Google Play Games using SignInWithGooglePlayGamesAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/google-play-games

Use this method to create a new player or sign in an existing player with Google Play Games credentials. It does not consider the cached player and replaces it. The example shows error handling for AuthenticationException and RequestFailedException.

```csharp
async Task SignInWithGooglePlayGamesAsync(string authCode)
{
    try
    {
        await AuthenticationService.Instance.SignInWithGooglePlayGamesAsync(authCode);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### UpdatePasswordAsync example

Source: https://docs.unity.com/en-us/authentication/platform-signin/username-password

Calls AuthenticationService.Instance.UpdatePasswordAsync with the current and new passwords. Catches AuthenticationException and RequestFailedException to handle errors. The player must be signed in and provide current and new passwords.

```csharp
async Task UpdatePasswordAsync(string currentPassword, string newPassword)
{
    try
    {
        await AuthenticationService.Instance.UpdatePasswordAsync(currentPassword, newPassword);
        Debug.Log("Password updated.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### Get the Authentication Subsystem from UGameInstance

Source: https://docs.unity.com/en-us/authentication-unreal/cpp-integration

Obtains a reference to the UAuthenticationSubsystem from the game instance. This subsystem handles authentication lifecycle and stores authentication information.

```cpp
UWorld* GameWorld = GetWorld();
UGameInstance* GameInstance = GameWorld->GetGameInstance();
UAuthenticationSubsystem* AuthenticationSubsystem = GameInstance->GetSubsystem<UAuthenticationSubsystem>();
```

--------------------------------

### Authenticate player with Facebook access token using SignInWithFacebookAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/facebook

Use this method to authenticate the player after they trigger the Facebook login by signing in or creating a new player profile and you have received the Facebook access token. It is similar to the first example but includes an extra space after 'await'.

```csharp
async Task SignInWithFacebookAsync(string token)
{
    try
    {
        await  AuthenticationService.Instance.SignInWithFacebookAsync(token);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}

```

--------------------------------

### Steam sign-in with GetAuthTicketForWebApi

Source: https://docs.unity.com/en-us/authentication/platform-signin/steam

C# example for Steam sign-in using Steamworks.Net SDK. It creates a callback for GetTicketForWebApiResponse_t, calls SteamUser.GetAuthTicketForWebApi with the identity string, and converts the ticket to a hex string. The identity must be alphanumeric and 5-30 characters long. The callback must be assigned to a member variable to prevent GC cleanup.

```csharp
Callback<GetTicketForWebApiResponse_t> m_AuthTicketForWebApiResponseCallback;
string m_SessionTicket;
string identity = "unityauthenticationservice";

void SignInWithSteam()
{
    // It's not necessary to add event handlers if they are
    // already hooked up.
    // Callback.Create return value must be assigned to a
    // member variable to prevent the GC from cleaning it up.
    // Create the callback to receive events when the session ticket
    // is ready to use in the web API.
    // See GetAuthSessionTicket document for details.
    m_AuthTicketForWebApiResponseCallback = Callback<GetTicketForWebApiResponse_t>.Create(OnAuthCallback);

    SteamUser.GetAuthTicketForWebApi(identity);
}

void OnAuthCallback(GetTicketForWebApiResponse_t callback)
{
    m_SessionTicket = BitConverter.ToString(callback.m_rgubTicket).Replace("-", string.Empty);
    m_AuthTicketForWebApiResponseCallback.Dispose();
    m_AuthTicketForWebApiResponseCallback = null;
    Debug.Log("Steam Login success. Session Ticket: " + m_SessionTicket);
    // Call Unity Authentication SDK to sign in or link with Steam, displayed in the following examples, using the same identity string and the m_SessionTicket.
}

```

--------------------------------

### GetSignInCodeInfoAsync and ConfirmCodeAsync - Get code info and confirm authorization

Source: https://docs.unity.com/en-us/authentication/platform-signin/code-link

Use GetSignInCodeInfoAsync to fetch SignInCode information and display it to the player for confirmation. Then call ConfirmCodeAsync to authorize the Code-Link sign in. ConfirmCodeAsync supports optional idProvider and externalToken parameters for consoles only; using them on other platforms returns an error.

```csharp
async Task GetCodeInfoAsync(string signInCode)
{
    try
    {
        var codeInfo = await AuthenticationService.Instance.GetSignInCodeInfoAsync(signInCode);
        // Display code, and expiration and identifier to the player and ask them to authorize the code-link sign in
    }
    catch (Exception e)
    {
        // Notify the client something went wrong getting the code information
    }
}

async Task ConfirmCodeAsync(string signInCode)
{
    try
    {
        await AuthenticationService.Instance.ConfirmCodeAsync(signInCode);
        // Display a confirmation that the device should be authorized
    }
    catch (Exception e)
    {
        // Notify the client something went wrong with the code confirmation
    }
}

```

--------------------------------

### Link anonymous player to Apple account using LinkWithAppleAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/apple

Call this method after signing in anonymously to link the cached player to an Apple account. It throws AuthenticationException with AccountAlreadyLinked if the user is already linked. The example includes error handling for both AuthenticationException and RequestFailedException.

```csharp
async Task LinkWithAppleAsync(string idToken)
{
    try
    {
        await AuthenticationService.Instance.LinkWithAppleAsync(idToken);
        Debug.Log("Link is successful.");
    }
    catch (AuthenticationException ex) when (ex.ErrorCode == AuthenticationErrorCodes.AccountAlreadyLinked)
    {
        // Prompt the player with an error message.
        Debug.LogError("This user is already linked with another account. Log in instead.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### Apple sign-in with Apple Unity Plugin (AppleAuthManager)

Source: https://docs.unity.com/en-us/authentication/platform-signin/apple

Example MonoBehaviour that uses the Sign in with the Apple Unity Plugin to perform Apple sign-in. It initializes an AppleAuthManager, updates it each frame, and calls LoginWithAppleId with options to include email and full name. On success it extracts the identity token and stores it in the Token property; on failure it logs the error and sets the Error property.

```csharp
using System.Text;
using UnityEngine;

// External dependencies
using AppleAuth;
using AppleAuth.Enums;
using AppleAuth.Interfaces;
using AppleAuth.Native;

public class AppleExampleScript : MonoBehaviour
{
    IAppleAuthManager m_AppleAuthManager;
    public string Token { get; private set; }
    public string Error { get; private set; }

    public void Initialize()
    {
        var deserializer = new PayloadDeserializer();
        m_AppleAuthManager = new AppleAuthManager(deserializer);
    }

   public void Update()
   {
      if (m_AppleAuthManager != null)
      {
         m_AppleAuthManager.Update();
      }
   }

    public void LoginToApple()
    {
        // Initialize the Apple Auth Manager
        if (m_AppleAuthManager == null)
        {
            Initialize();
        }

        // Set the login arguments
        var loginArgs = new AppleAuthLoginArgs(LoginOptions.IncludeEmail | LoginOptions.IncludeFullName);

        // Perform the login
        m_AppleAuthManager.LoginWithAppleId(
            loginArgs,
            credential =>
            {
                var appleIDCredential = credential as IAppleIDCredential;
                if (appleIDCredential != null)
                {
                    var idToken = Encoding.UTF8.GetString(
                        appleIDCredential.IdentityToken,
                        0,
                        appleIDCredential.IdentityToken.Length);
                    Debug.Log("Sign-in with Apple successfully done. IDToken: " + idToken);
                    Token = idToken;
                }
                else
                {
                    Debug.Log("Sign-in with Apple error. Message: appleIDCredential is null");
                    Error = "Retrieving Apple Id Token failed.";
                }
            },
            error =>
            {
                Debug.Log("Sign-in with Apple error. Message: " + error);
                Error = "Retrieving Apple Id Token failed.";
            }
        );
    }
}
```

--------------------------------

### Initialize(FSubsystemCollectionBase&)

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-subsystem

Initialize overrides from USubsystem.

```APIDOC
## Initialize(FSubsystemCollectionBase&)

### Description
Initialize overrides from USubsystem.

### Declaration
```cpp
virtual void Initialize(FSubsystemCollectionBase& Collection) override
```

```

--------------------------------

### GetProfileNames

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-blueprint-api

Blueprint-pure method to get all active player profile names.

```APIDOC
## GetProfileNames

### Description
Returns all active player profile names.

### Declaration
```cpp
UFUNCTION(BlueprintPure, Category = "Unity Gaming Services | Authentication")
TArray<FString> GetProfileNames() const
```

### Returns
- **TArray<FString>** - All the active player profile names.
```

--------------------------------

### Get Profile Names Declaration

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-blueprint-api

BlueprintPure method to return all active player profile names.

```cpp
UFUNCTION(BlueprintPure, Category = "Unity Gaming Services | Authentication")
TArray<FString> GetProfileNames() const
```

--------------------------------

### Get Current Profile Name Declaration

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-blueprint-api

BlueprintPure method to return the name of the current profile.

```cpp
UFUNCTION(BlueprintPure, Category = "Unity Gaming Services | Authentication")
FString GetCurrentProfileName() const
```

--------------------------------

### Sign up with username and password

Source: https://docs.unity.com/en-us/authentication/platform-signin/username-password

Use the SignUpWithUsernamePasswordAsync method to create a new player. The username is case insensitive, requires 3-20 characters, and supports letters, numbers, and the symbols _ . - @. The password is case sensitive, requires 8-30 characters, and must include at least one lowercase letter, one uppercase letter, one number, and one symbol.

```csharp
async Task SignUpWithUsernamePasswordAsync(string username, string password)
{
    try
    {
        await AuthenticationService.Instance.SignUpWithUsernamePasswordAsync(username, password);
        Debug.Log("SignUp is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### FAuthenticationGetUserDelegate declaration

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-blueprint-api

Declares a dynamic delegate for getting user information, passing an FAuthenticationUserResponse parameter.

```cpp
DECLARE_DYNAMIC_DELEGATE_OneParam(FAuthenticationGetUserDelegate, FAuthenticationUserResponse, Response)
```

--------------------------------

### Sign in with Steam using SignInWithSteamAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/steam

Use this method to sign in a returning player or create a new player with Steam credentials. It does not consider the cached player and replaces it. The method throws AuthenticationException or RequestFailedException on failure.

```csharp
async Task SignInWithSteamAsync(string ticket, string identity)
{
    try
    {
        await AuthenticationService.Instance.SignInWithSteamAsync(ticket, identity);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### GetState() - Retrieve authentication state

Source: https://docs.unity.com/en-us/authentication-unreal/cpp-integration

Retrieves the current state of the authentication session. Note: The example uses GetUserId() but the method described is GetState().

```cpp
EAuthenticationState UserId = AuthenticationSubsystem->GetUserId();
```

--------------------------------

### Sign in with Facebook using SignInWithFacebookAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/facebook

Use this method to sign in a returning player or create a new player with Facebook credentials. If no Unity Authentication player is associated with the credentials, it creates a new player; otherwise it signs into the existing player's account. This function does not consider the cached player and replaces it.

```csharp
async Task SignInWithFacebookAsync(string token)
{
    try
    {
        await AuthenticationService.Instance.SignInWithFacebookAsync(token);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}

```

--------------------------------

### Get User Info Declaration

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-blueprint-api

BlueprintCallable method to return the current player's player info, such as account creation time and linked external ids.

```cpp
UFUNCTION(BlueprintCallable, Category = "Unity Gaming Services | Authentication")
void GetUserInfo(FAuthenticationGetUserDelegate ResponseDelegate) const
```

--------------------------------

### Sign In With Custom ID API - Initial Sign-Up

Source: https://docs.unity.com/en-us/authentication/platform-signin/custom-id

Use this curl command to sign up a player with a custom ID. It requires a stateless token obtained from the Token Exchange API. The response contains an idToken and sessionToken to return to the game client for initializing AuthenticationService.

```bash
curl --location 'https://player-auth.services.api.unity.com/v1/projects/<PROJECT_ID>/authentication/server/custom-id' \
--header 'Content-Type: application/json' \
--header 'UnityEnvironment: <ENVIRONMENT_NAME>' \
--header 'Authorization: Bearer <STATELESS_TOKEN' \
--data '{
    "externalId": "YOUR_CUSTOM_PLAYER_ID"
}'
```

--------------------------------

### Unlink Facebook account with error handling

Source: https://docs.unity.com/en-us/authentication/platform-signin/facebook

Example implementation of unlinking a Facebook account with error handling for AuthenticationException and RequestFailedException. Compare error codes to AuthenticationErrorCodes and CommonErrorCodes respectively.

```csharp
async Task UnlinkFacebookAsync()
{
   try
   {
       await AuthenticationService.Instance.UnlinkFacebookAsync();
       Debug.Log("Unlink is successful.");
   }
   catch (AuthenticationException ex)
   {
       // Compare error code to AuthenticationErrorCodes
       // Notify the player with the proper error message
       Debug.LogException(ex);
   }
   catch (RequestFailedException ex)
   {
       // Compare error code to CommonErrorCodes
       // Notify the player with the proper error message
       Debug.LogException(ex);
   }
}
```

--------------------------------

### Sign in with username and password

Source: https://docs.unity.com/en-us/authentication/platform-signin/username-password

Use the SignInWithUsernamePasswordAsync method to sign in an existing player. The method throws AuthenticationException for authentication errors and RequestFailedException for other request failures, which are caught and logged.

```csharp
async Task SignInWithUsernamePasswordAsync(string username, string password)
{
    try
    {
        await AuthenticationService.Instance.SignInWithUsernamePasswordAsync(username, password);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### SignInWith* API for switching to initial account

Source: https://docs.unity.com/en-us/authentication/identity-management

Use the SignInWith* API to switch to the initial account when a linking conflict occurs.

```csharp
SignInWith*
```

--------------------------------

### Get Google ID token with PlayGamesLocalUser

Source: https://docs.unity.com/en-us/authentication/platform-signin/google

Retrieves the Google ID token using the Google Play Games plugin for Unity v10.14. This token is required for the two-step Google sign-in process with Unity Authentication.

```csharp
{
    ((PlayGamesLocalUser)Social.localUser).GetIdToken()
}
```

--------------------------------

### SignInWithGoogleAsync - Sign in or create player with Google

Source: https://docs.unity.com/en-us/authentication/platform-signin/google

Signs in a returning player or creates a new player using Google credentials. The method takes a Google ID token and calls AuthenticationService.Instance.SignInWithGoogleAsync. It catches AuthenticationException and RequestFailedException to handle errors, comparing error codes to AuthenticationErrorCodes and CommonErrorCodes respectively.

```csharp
async Task SignInWithGoogleAsync(string idToken)
{
    try
    {
        await AuthenticationService.Instance.SignInWithGoogleAsync(idToken);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### Initialize override

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-subsystem

Override of Initialize from USubsystem.

```cpp
virtual void Initialize(FSubsystemCollectionBase& Collection) override
```

--------------------------------

### Unlink Unity Player Account with UnlinkUnityAsync

Source: https://docs.unity.com/en-us/authentication/unity-player-accounts

Use AuthenticationService.Instance.UnlinkUnityAsync to unlink the player's Unity Player account. After unlinking, if the account is not linked to any other identity, it becomes anonymous. The example shows try/catch handling for AuthenticationException and RequestFailedException.

```csharp
async Task UnlinkUnityAsync()
{
   try
   {
       await AuthenticationService.Instance.UnlinkUnityAsync();
       Debug.Log("Unlink is successful.");
   }
   catch (AuthenticationException ex)
   {
       // Compare error code to AuthenticationErrorCodes
       // Notify the player with the proper error message
       Debug.LogException(ex);
   }
   catch (RequestFailedException ex)
   {
       // Compare error code to CommonErrorCodes
       // Notify the player with the proper error message
       Debug.LogException(ex);
   }
}
```

--------------------------------

### ShouldCreateSubsystem(UObject*)

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-subsystem

Initialize overrides from USubsystem.

```APIDOC
## ShouldCreateSubsystem(UObject*)

### Description
Initialize overrides from USubsystem.

### Declaration
```cpp
virtual bool ShouldCreateSubsystem(UObject* Outer) const override
```

```

--------------------------------

### Unlink Apple account with UnlinkAppleAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/apple

Use the UnlinkAppleAsync API to unlink a player's Apple account. After unlinking, if the account is not linked to any additional identity, it transitions to an anonymous account. The example catches AuthenticationException and RequestFailedException to handle errors.

```csharp
async Task UnlinkAppleAsync()
{
   try
   {
       await AuthenticationService.Instance.UnlinkAppleAsync();
       Debug.Log("Unlink is successful.");
   }
   catch (AuthenticationException ex)
   {
       // Compare error code to AuthenticationErrorCodes
       // Notify the player with the proper error message
       Debug.LogException(ex);
   }
   catch (RequestFailedException ex)
   {
       // Compare error code to CommonErrorCodes
       // Notify the player with the proper error message
       Debug.LogException(ex);
   }
}
```

--------------------------------

### Implement Facebook login with Unity Authentication

Source: https://docs.unity.com/en-us/authentication/platform-signin/facebook

Sample MonoBehaviour that initializes the Facebook SDK, handles app activation, pauses/resumes the game on focus changes, and performs a login with read permissions. Requires the Facebook SDK and Unity Authentication configured with Facebook as an ID Provider. On login success it stores the access token in the Token field; on cancellation it sets Error and logs a message.

```csharp
using System.Collections.Generic;
using UnityEngine;

// Other needed dependencies
using Facebook.Unity;

public class FacebookExampleScript : MonoBehaviour
{
    public string Token;
    public string Error;

    // Awake function from Unity's MonoBehaviour
    void Awake()
    {
        if (!FB.IsInitialized)
        {
            // Initialize the Facebook SDK
            FB.Init(InitCallback, OnHideUnity);
        }
        else
        {
            // Already initialized, signal an app activation App Event
            FB.ActivateApp();
        }
    }

    void InitCallback()
    {
        if (FB.IsInitialized)
        {
            // Signal an app activation App Event
            FB.ActivateApp();
            // Continue with Facebook SDK
        }
        else
        {
            Debug.Log("Failed to Initialize the Facebook SDK");
        }
    }

    void OnHideUnity(bool isGameShown)
    {
        if (!isGameShown)
        {
            // Pause the game - we will need to hide
            Time.timeScale = 0;
        }
        else
        {
            // Resume the game - we're getting focus again
            Time.timeScale = 1;
        }
    }

    public void Login()
    {
        // Define the permissions
        var perms = new List<string>() { "public_profile", "email" };

        FB.LogInWithReadPermissions(perms, result =>
        {
            if (FB.IsLoggedIn)
            {
                Token = AccessToken.CurrentAccessToken.TokenString;
                Debug.Log($"Facebook Login token: {Token}");
            }
            else
            {
                Error = "User cancelled login";
                Debug.Log("[Facebook Login] User cancelled login");
            }
        });
    }
}
```

--------------------------------

### Link anonymous player to Google Play Games using LinkWithGooglePlayGamesAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/google-play-games

Use this method to link a cached player to a Google Play Games account after anonymous sign-in. The example includes handling for the AccountAlreadyLinked error, prompting the player to log in instead.

```csharp
async Task LinkWithGooglePlayGamesAsync(string authCode)
{
    try
    {
        await AuthenticationService.Instance.LinkWithGooglePlayGamesAsync(authCode);
        Debug.Log("Link is successful.");
    }
    catch (AuthenticationException ex) when (ex.ErrorCode == AuthenticationErrorCodes.AccountAlreadyLinked)
    {
        // Prompt the player with an error message.
        Debug.LogError("This user is already linked with another account. Log in instead.");
    }

    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### Include the AuthenticationSubsystem header

Source: https://docs.unity.com/en-us/authentication-unreal/cpp-integration

Includes the AuthenticationSubsystem.h header file to access the Authentication Subsystem in your class.

```cpp
#include "AuthenticationSubsystem.h"
```

--------------------------------

### Deinitialize()

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-subsystem

Initialize overrides from USubsystem.

```APIDOC
## Deinitialize()

### Description
Initialize overrides from USubsystem.

### Declaration
```cpp
virtual void Deinitialize() override
```

```

--------------------------------

### Sign in with Apple Game Center using SignInWithAppleGameCenterAsync

Source: https://docs.unity.com/en-us/authentication/platform-signin/apple-game-center

Use this method to sign in a returning player or create a new player with Apple Game Center credentials. It creates a new player if no Unity Authentication player is associated with the credentials, otherwise signs into the existing player's account. This function does not consider the cached player and replaces it.

```csharp
async Task SignInWithAppleGameCenterAsync(string signature, string teamPlayerId, string   publicKeyURL, string salt, ulong timestamp)
{
    try
    {
        await AuthenticationService.Instance.SignInWithAppleGameCenterAsync(signature, teamPlayerId, publicKeyURL, salt, timestamp);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### OpenID sign-in with SignInOpenID

Source: https://docs.unity.com/en-us/authentication/uas-native-sdk

Uses SignInOpenID with an IdToken, IdProvider name, and a sign-in callback to create a new authentication session connected to the OpenID provider. The associated AuthenticationPlayer is available via GetPlayer().

```C++
auto IdToken = "AnOpenIdToken";
    auto IdProvider = "OpenIdProviderName";
    cb = [this](const unity::uaslib::AuthenticationSignInResponse &response) {
        std::cout << "Authentication Sign In Response:\n";
        std::cout << "Token: " << response.Token << "\n";
        std::cout << "PlayerId: " << response.PlayerId << "\n";
        std::cout << "ExpiresIn: " << response.ExpiresIn << "\n";
    };
    client.SignInOpenID(IdToken, IdProvider, cb);

```

--------------------------------

### UAuthenticationSubsystem()

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-subsystem

Default constructor for the Authentication subsystem.

```APIDOC
## UAuthenticationSubsystem()

### Description
Default constructor for the Authentication subsystem.

### Declaration
```cpp
UAuthenticationSubsystem()
```

```

--------------------------------

### OIDC name prefix and issuer URL formats for OpenID Connect ID providers

Source: https://docs.unity.com/en-us/authentication/openid-connect

The OIDC name must be between 6 and 20 characters and include the prefix 'oidc-'. The issuer URL must start with https:// and follow the format shown for AWS Cognito, Keycloak, and Firebase.

```text
oidc-

```

```text
https://cognito-idp.<Region>.amazonaws.com/<userPoolId>

```

```text
https://<keycloak-domain>/realms/<realm>

```

```text
https://securetoken.google.com/<projectId>

```

--------------------------------

### SignInWithOpenIdConnectAsync method for OpenID Connect sign-in

Source: https://docs.unity.com/en-us/authentication/openid-connect

Signs in an existing player or creates a new one using OpenID Connect credentials. The method replaces the cached player and throws AuthenticationException or RequestFailedException on failure.

```csharp
async Task SignInWithOpenIdConnectAsync(string idProviderName, string idToken)
{
    try
    {
        await AuthenticationService.Instance.SignInWithOpenIdConnectAsync(idProviderName, idToken);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
        {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}

```

--------------------------------

### Include AuthenticationStates.h

Source: https://docs.unity.com/en-us/authentication-unreal/sdk-api/authentication/authentication-states

Include the header file for the authentication states enum.

```cpp
#include "AuthenticationStates.h"
```

--------------------------------

### Retrieve Oculus user and generate nonce with Oculus.Platform

Source: https://docs.unity.com/en-us/authentication/platform-signin/oculus

Use this MonoBehaviour to retrieve the logged-in Oculus user and generate a nonce for Unity Authentication. It initializes the Oculus Platform, checks entitlement, gets the user ID (using msg.Data.ID, not OculusID), and obtains a user proof nonce. Requires the Meta Integration package and an Oculus headset in developer mode with USB Connection Dialog enabled.

```csharp
using UnityEngine;
using Oculus.Platform;
using Oculus.Platform.Models;

public class OculusAuth : MonoBehaviour
{
    private string userId;

    private void Start()
    {
        Core.AsyncInitialize().OnComplete(OnInitializationCallback);
    }

    private void OnInitializationCallback(Message<PlatformInitialize> msg)
    {
        if (msg.IsError)
        {
            Debug.LogErrorFormat("Oculus: Error during initialization. Error Message: {0}",
                msg.GetError().Message);
        }
        else
        {
            Entitlements.IsUserEntitledToApplication().OnComplete(OnIsEntitledCallback);
        }
    }

    private void OnIsEntitledCallback(Message msg)
    {
        if (msg.IsError)
        {
            Debug.LogErrorFormat("Oculus: Error verifying the user is entitled to the application. Error Message: {0}",
                msg.GetError().Message);
        }
        else
        {
            GetLoggedInUser();
        }
    }

    private void GetLoggedInUser()
    {
        Users.GetLoggedInUser().OnComplete(OnLoggedInUserCallback);
    }

    private void OnLoggedInUserCallback(Message<User> msg)
    {
        if (msg.IsError)
        {
            Debug.LogErrorFormat("Oculus: Error getting logged in user. Error Message: {0}",
                msg.GetError().Message);
        }
        else
        {
            userId = msg.Data.ID.ToString(); // do not use msg.Data.OculusID;
            GetUserProof();
        }
    }

    private void GetUserProof()
    {
        Users.GetUserProof().OnComplete(OnUserProofCallback);
    }

    private void OnUserProofCallback(Message<UserProof> msg)
    {
        if (msg.IsError)
        {
            Debug.LogErrorFormat("Oculus: Error getting user proof. Error Message: {0}",
                msg.GetError().Message);
        }
        else
        {
            string oculusNonce = msg.Data.Value;
            // Authentication can be performed here
        }
    }
}

```

--------------------------------

### Sign in with Steam for Additional App IDs

Source: https://docs.unity.com/en-us/authentication/platform-signin/steam

Use this method to sign in a player to an Additional App ID (e.g., Demo, PlayTest, Alpha) using their Steam session ticket. Assumes you already have the player's Steam session ticket via GetAuthTicketForWebApi and passed the same identity parameter. The player has the same Unity Authentication Player ID for all App IDs under the same project, so use best judgement to scope player data appropriately.

```csharp
async Task SignInWithSteamAsync(string ticket, string identity, string appId)
{
    try
    {
        await AuthenticationService.Instance.SignInWithSteamAsync(ticket, identity, appId);
        Debug.Log("SignIn is successful.");
    }
    catch (AuthenticationException ex)
    {
        // Compare error code to AuthenticationErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
    catch (RequestFailedException ex)
    {
        // Compare error code to CommonErrorCodes
        // Notify the player with the proper error message
        Debug.LogException(ex);
    }
}
```

--------------------------------

### Link a returning player with LinkWithUnityAsync

Source: https://docs.unity.com/en-us/authentication/unity-player-accounts

Calls AuthenticationService.Instance.LinkWithUnityAsync(accessToken) to link the current player to Unity Player Accounts. The player must be signed in to Unity Authentication for linking to succeed. Handles AuthenticationException (including AccountAlreadyLinked) and RequestFailedException with appropriate error messages.

```csharp
async Task LinkWithUnityAsync(string accessToken)
        {
            try
            {
                await AuthenticationService.Instance.LinkWithUnityAsync(accessToken);
                Debug.Log("Link is successful.");
            }
            catch (AuthenticationException ex) when (ex.ErrorCode == AuthenticationErrorCodes.AccountAlreadyLinked)
            {
                // Prompt the player with an error message.
                Debug.LogError("This user is already linked with another account. Log in instead.");
            }
            catch (AuthenticationException ex)
            {
                // Compare error code to AuthenticationErrorCodes
                // Notify the player with the proper error message
                Debug.LogException(ex);
            }
            catch (RequestFailedException ex)
            {
                // Compare error code to CommonErrorCodes
                // Notify the player with the proper error message
                Debug.LogException(ex);
            }
        }
```

--------------------------------

### Initialize Play Games login with ID token request

Source: https://docs.unity.com/en-us/authentication/platform-signin/google

Configures and activates the Play Games Platform for Google sign-in. Requests an ID token for identifying the player to other services like Firebase. Must be called before authenticating.

```csharp
void InitializePlayGamesLogin()
{
    var config = new PlayGamesClientConfiguration.Builder()
        // Requests an ID token be generated.
        // This OAuth token can be used to
        // identify the player to other services such as Firebase.
        .RequestIdToken()
        .Build();

    PlayGamesPlatform.InitializeInstance(config);
    PlayGamesPlatform.DebugLogEnabled = true;
    PlayGamesPlatform.Activate();
}
```

--------------------------------

### SignInWithCodeAsync - Sign in with code

Source: https://docs.unity.com/en-us/authentication/platform-signin/code-link

Call SignInWithCodeAsync on the device that generated the SignInCode. The credentials are stored in memory, so GenerateSignInCodeAsync must be called first or it throws an exception. If the code is not yet authorized, the method succeeds but the player isn't signed in; listen for the SignedIn event.

```csharp
public async Task SignInWithCodeAsync()
{
    try
    {
        AuthenticationService.Instance.SignedIn += UserHasSignedIn;
        await AuthenticationService.Instance.SignInWithCodeAsync();
    }
    catch (Exception e)
    {
        // Notify the client something went wrong signing in the player
    }
    finally
    {
        AuthenticationService.Instance.SignedIn -= UserHasSignedIn;
    }
}

public void UserHasSignedIn() {
    // Notify the client the user signed in successfully.
}

```
Tokens:
Raw