Sign-in

Flock supports several player sign-in methods, all through the SDK. See Authentication for how the SDK manages game and player sessions.

Scope: players are accounts within a single game.

Dashboard
Unity
Unreal

Browse and manage your game’s players from the Flock dashboard — search accounts, inspect profiles, and review linked providers.

Players list — Browse and manage players in the Flock dashboard.

Each method is a LoginWith…Async call on FlockClient.Instance.Authentication. They throw on failure.

Email / password

LoginWithEmailAsync — classic account sign-in.

Device ID

LoginWithDeviceAsync — frictionless guest sign-in keyed to a device.

Google / Apple

LoginWithGoogleAsync / LoginWithAppleAsync — platform identity.

Steam / Facebook / Discord

LoginWithSteamAsync, LoginWithFacebookAsync, LoginWithDiscordAsync (the last two are login-only: link them to an existing account first).

The examples run inside an async method; email and password are your own values.

using Flock;
using UnityEngine;

await FlockClient.Instance.Authentication.LoginWithEmailAsync(email, password);
Debug.Log($"Signed in as {FlockClient.Instance.CurrentPlayerId}");

A new player must register before they can log in. LoginWith…Async never creates an account — it only signs in one that already exists. Calling it for someone who has never registered fails with player.invalid_login_credentials (FlockErrorCode.PlayerInvalidLoginCredentials).This catches people most often on device sign-in, where it feels like a guest flow that should just work. Log in, and register when the device has no account yet:

using Flock;
using Flock.Exceptions;

try
{
    // Every launch after the first.
    await FlockClient.Instance.Authentication.LoginWithDeviceAsync();
}
catch (FlockException notRegistered) when (notRegistered.ErrorCode == FlockErrorCode.PlayerInvalidLoginCredentials)
{
    // The first launch on this device: creates the account AND signs in.
    await FlockClient.Instance.Authentication.RegisterWithDeviceAsync();
}

Registering an identity that already has an account does not throw — it returns null and leaves the player signed out, so a register that returns null must be followed by a login.

A successful RegisterWith…Async also signs the player in, so there is no second call on the happy path. With no ID, the device calls use the device ID the SDK makes on the first launch and keeps for this install. A game that already signed players in with an ID of its own (such as SystemInfo.deviceUniqueIdentifier) keeps passing that ID, or its players get new accounts; Your first call has the details. If you do get the order wrong, the exception says so and names the method to call instead; see Error handling.

Each method is an async node under Flock | Auth with On Success and On Failure pins, or a call on the auth provider in C++. The SDK exchanges the credential your platform SDK produced for a Flock session.

#include "FlockSubsystem.h"
#include "Providers/FlockAuthProvider.h"

UFlockSubsystem* Sdk = UFlockSubsystem::Get(this);   // this: any object in the game's world
if (Sdk->IsAuthenticated())
{
    return;   // Signed in already: a second sign-in would end this one.
}

// Email and Password: what the player typed into your sign-in screen.
Sdk->GetAuthProvider()->LoginWithEmail(Email, Password,
    [](TFlockResult<FFlockPlayerLoginResponse> Result)
    {
        if (Result.bSuccess) { /* Result.Value.PlayerId */ }
    });

A new player must register before they can log in. LoginWith… never creates an account: calling it for someone who has never registered fails with player.invalid_login_credentials. A successful RegisterWith… creates the account and signs the player in. Registering an identity that already has an account is reported as a success with bAlreadyRegistered set, and leaves the player signed out, so follow it with a login.

For device sign-in, sign in only when nobody is signed in yet (a saved sign-in is restored as the SDK starts, and a second sign-in ends the session the first one started), register first, and log in when the device already has an account. Leave the device ID empty: the device calls then use the one the SDK makes once and keeps for this install.

#include "FlockSubsystem.h"

void AMyActor::SignInWithThisDevice()
{
    UFlockSubsystem* Sdk = UFlockSubsystem::Get(this);   // this: any object in the game's world
    if (!Sdk || !Sdk->IsInitialized() || Sdk->IsAuthenticated())
    {
        return;   // Not started, or a player is signed in already: Flock restores a saved sign-in as it starts.
    }

    const TWeakObjectPtr<UFlockSubsystem> Flock = Sdk;

    // An empty device ID: this install's own. Name: an optional display name, unique in the game; empty leaves it out.
    Sdk->GetAuthProvider()->RegisterWithDevice(FString(), FString(), [Flock](TFlockResult<FFlockRegisterResult> Registered)
    {
        if (!Registered.bSuccess)
        {
            UE_LOG(LogTemp, Warning, TEXT("%s"), *Registered.Error.ToDisplayText());   // what is wrong, then a Fix: line
            return;
        }
        if (!Registered.Value.bAlreadyRegistered)
        {
            return;   // a new account, and the player is signed in: Registered.Value.Response.PlayerId
        }

        // This device already has an account, and registering left the player signed out: log in.
        if (Flock.IsValid())
        {
            Flock->GetAuthProvider()->LoginWithDevice(FString(), [](TFlockResult<FFlockPlayerLoginResponse> LoggedIn)
            {
                if (!LoggedIn.bSuccess)
                {
                    UE_LOG(LogTemp, Warning, TEXT("%s"), *LoggedIn.Error.ToDisplayText());
                }
            });
        }
    });
}

The SDK keeps that ID in Saved/Flock/device_id.txt; read it with ThisDeviceId() on the auth provider (Flock Get This Device Id in Blueprint). Any other ID is sent exactly as you pass it, and a game that already signs players in with a device ID of its own must keep passing it, or those players get a new, empty account: the Unreal SDK page says when to pass your own. Every RegisterWith… call takes the same Name argument: a display name the server keeps unique (check one first with IsNameAvailable), or empty for none. Facebook and Discord are login-only; an account must already exist. A sign-in raises On Authenticated on Flock’s events (GetEvents()), whichever call made it.In Blueprint, start with a Branch on Flock Is Authenticated, and sign in only on False. Flock Register With Device takes Device Id and Name; its On Success carries the result, whose Already Registered says to follow with Flock Login With Device. Leave Device Id empty on both to use this install’s ID; the picture hands them the event’s Device Id input, so call the event with it empty. The Unreal SDK page shows each step.

A Sign In With This Device custom event, with no inputs and both Device Id pins left empty so the SDK's kept id is used, branches on Flock Is Authenticated: True prints Already signed in; False runs Flock Register With Device, whose On Success breaks the result and branches on Already Registered: True runs Flock Login With Device, which prints Signed in, and False prints Registered and signed in; each On Failure prints the error through To String (Flock Error) — Sign in once: when nobody is signed in, register this device, and log in when it already has an account.

See the Unreal SDK guide for the full provider table.

Sessions

The SDK keeps the player signed in and refreshes their session automatically — you never handle tokens or expiry yourself. If a player needs to re-authenticate, the SDK raises FlockEvents.OnAuthExpired (Unreal: On Auth Expired on Flock’s events, GetEvents()).

Getting Started

Concepts

Features

Reference

Email / password

Device ID

Google / Apple

Steam / Facebook / Discord

Sessions

Email / password

Device ID

Google / Apple

Steam / Facebook / Discord

​Sessions

Sessions