Unreal SDK

The Flock Unreal SDK connects your game to the Flock backend: player auth, save data, economy, remote config, and analytics — configured from Project Settings, with typed Blueprint nodes or C++ generated from your own schemas. Every feature works from Blueprint. Each call is a self-contained async node with success and failure pins, and no Target pin to wire — nodes resolve the SDK from the graph they sit in.

Download the Unreal SDK

Get the latest plugin release from GitHub.

Early access. Everything below ships today. Downloadable assets are the one Unity feature not yet in the Unreal SDK — it lands in a later release.

Requirements

Unreal Engine 5.5
A C++ project. Blueprint-only projects need the C++ toolchain installed to compile the plugin.

Setup

Install the plugin

Download the latest release and extract it into your project’s Plugins/ folder, so you have YourProject/Plugins/FlockUnrealSdk/.Then right-click your .uproject → Generate Visual Studio project files, and rebuild. The plugin is enabled by default — verify under Edit → Plugins → Online Platform → Flock SDK.

Configure

Open Project Settings → Plugins → Flock SDK and fill in the four fields from your game’s page on the dashboard:

Field	Value
API URL	Leave the default (`https://api-flock.qwacks.com`) unless told otherwise
API Key	Identifies your game — treat it like a password
Game Name	Your game’s name from the dashboard
Game Version	Your game version name, e.g. `1.0.0`

Values are saved into your project’s DefaultGame.ini.

Let the version bake

The Game Version ID resolves and bakes itself as soon as those fields are valid, so startup never makes a network call to find it. You can force it any time with Tools → Flock → Resolve Game Version.

Your first call

The SDK auto-initializes with your game, so there is nothing to start. Sign a player in, then read something back.

A Blueprint graph running Flock Login With Device into Flock Get Game — Sign in on BeginPlay, then read the game record — no Target pin on either node.

UFlockSubsystem* Sdk = UFlockSubsystem::Get(this);

Sdk->GetAuthProvider()->LoginWithDevice(DeviceId,
    [Sdk](TFlockResult<FFlockPlayerLoginResponse> Login)
    {
        if (!Login.bSuccess) { return; }

        Sdk->GetGameProvider()->GetGame(
            [](TFlockResult<FFlockGameSchema> Game)
            {
                UE_LOG(LogTemp, Log, TEXT("Playing %s"), *Game.Value.Name);
            });
    });

Initialization

Auto-Initialize On Load is on by default, so UFlockSubsystem is running before BeginPlay. To defer past a splash screen or EULA, turn it off and call InitializeFromSettings() yourself. Because init reads a baked version ID, it is synchronous and makes no network call — your game starts the same offline as online.

Authenticate a player

Email, device ID, Google, Apple, Steam, Facebook, and Discord. The SDK exchanges the credential your platform SDK produced for a Flock session, stores the tokens encrypted between launches, restores the session automatically on startup, and refreshes expired access tokens silently.

Flock Login With Email and Flock Register With Device nodes in a Blueprint graph — Login and register are separate calls — registering does not sign the player in.

Sdk->GetAuthProvider()->LoginWithEmail(Email, Password,
    [](TFlockResult<FFlockPlayerLoginResponse> Result)
    {
        if (Result.bSuccess)
        {
            UE_LOG(LogTemp, Log, TEXT("Signed in as %s"), *Result.Value.PlayerId);
        }
    });

You never pass a player ID. Reads and commands act for the signed-in player; the Player Id pin is tucked into each node’s advanced section for the rarer case of acting on someone else.

Work with your game data

One menu click turns your backend’s templates, configs, and shops into typed nodes. Tools → Flock → Sync Schemas — no C++, no toolchain, no compile step.

The Tools menu showing Resolve Game Version, Sync Schemas and Clean Generated — Tools → Flock → Sync Schemas generates typed assets from your own schemas.

Reading a config becomes one node that carries its own fetch and ID:

A generated Get Gameplay macro node feeding a Break node — Get Gameplay fetches, converts, and hands back a typed struct — break it for real pins.

Changing a player’s data is Get → the engine’s Set members in struct → Save:

Get Player Level into Set members into Save Player Level — Get hands out the row ID alongside the struct, because Save needs it.

Tick the members you want to write. Unticked ones keep whatever Get fetched.

The Details panel for a Set members in struct node — Ticking a member exposes its pin — untouched members are left exactly as they were.

Shop purchases and currency grants take a generated dropdown rather than an ID you type:

A Flock Purchase node in a Blueprint graph — Purchase by picking an item — the ID is baked in and cannot be mistyped.

Prefer C++?

Switch Codegen Target to C++ and a sync emits a generated module instead — a USTRUCT per template and config, a UENUM per ID set, and a typed call surface.

The Codegen Target setting in Project Settings — Codegen Target picks what a sync emits. Blueprint is the default.

FFlockGenerated::GetPlayerLevel(this,
    [this](TFlockResult<FPlayerLevelTemplate> Result, const FString& RowId)
    {
        if (!Result.bSuccess) { return; }

        FPlayerLevelTemplate Progress = Result.Value;
        Progress.Level.Stage = 5;
        FFlockGenerated::SavePlayerLevel(this, RowId, Progress, nullptr);
    });

FFlockGenerated::Purchase(this, EFlockShopItemId::GemPack, OnBought);
FFlockGenerated::AddFunds(this, EFlockCurrencyId::Gold, 100, OnCredited);

A project uses one target or the other. Generated C++ structs are BlueprintType, so graphs still see your types after switching.

Explore features

Players & auth

Player data

Shops & inventory

Remote config

Analytics & events

Advanced settings

Project Settings also tunes analytics, HTTP retries, the offline cache, and the codegen paths. The defaults are sensible — change them only when you need to. Turning on Enable Debug Logs traces every network call under the LogFlock category, and each line names its caller so you can tell a Blueprint graph from C++:

[Flock SDK] -> GET .../v1/player_data?player_id=01KY... [Blueprint 'bpTest']
[Flock SDK] <- 200 GET .../v1/player_data?player_id=01KY... (34 ms, 2060 bytes) [Blueprint 'bpTest']

Offline caching

Config, game, shop-catalog, and player-template reads are cached to disk, scoped to your game version, and served when the server is unreachable — the server is always tried first, and there are no TTLs. Player data writes queue offline and replay automatically when the connection returns. Currency grants never do: a grant fails rather than being queued, and is never re-sent after an ambiguous failure, so it cannot double-credit.

Error handling

Every call answers with a TFlockResult<T> rather than throwing — Unreal builds with exceptions off. Check bSuccess, then read Value or Error.

if (!Result.bSuccess && Result.Error.Code == EFlockErrorCode::ShopInsufficientFunds)
{
    // The server declined — not enough funds.
}

In Blueprint, every async node has an On Failure pin carrying the same Error, and UFlockErrorLibrary turns it into display text or a coded-error check without matching strings.

The full API reference, per-feature guides, and codegen details live in the SDK README.

Getting Started

Concepts

SDKs

Features

Reference

Download the Unreal SDK

Requirements

Setup

Your first call

Initialization

Authenticate a player

Work with your game data

Prefer C++?

Explore features

Players & auth

Player data

Shops & inventory

Remote config

Analytics & events

Advanced settings

Offline caching

Error handling

Download the Unreal SDK

​Requirements

​Setup

​Your first call

​Initialization

​Authenticate a player

​Work with your game data

​Prefer C++?

​Explore features

Players & auth

Player data

Shops & inventory

Remote config

Analytics & events

​Advanced settings

​Offline caching

​Error handling

Requirements

Setup

Your first call

Initialization

Authenticate a player

Work with your game data

Prefer C++?

Explore features

Advanced settings

Offline caching

Error handling