Quickstart

This guide takes you from a fresh game to your first signed-in player using the Flock SDK.

Create a studio and game

Open the Qwacks dashboard at platform.qwacks.com. One Qwacks account opens DataDuck, Flock and Protokite: with no account yet, choose Sign Up, otherwise Sign In.

Create the studio. A new account lands on Create Your Studio. Type the studio’s name and press Create Studio. A studio is your team’s workspace: its members, its plan and its games.
Create the game. The home page then asks you to Create your first game. Fill in Game name, a description and the Development stage, then press Create Game & Continue. A game holds everything Flock keeps for it: its players, its economy and its settings. Add more games later with Add game at the top of the page. Only a studio admin or manager can add a game.
Open Flock. Pick Flock among the products on the home page.

Success: the home page says your game is ready, and Flock opens on it: the menu at the top of the page shows your studio, the game and its version.

The Create Game form, with Game Name, Description and Development Stage — The Create Game form, opened with Add game on the Qwacks home page.

Your game already has a Game Version. A Game Version is one complete set of what your game reads from Flock: its configs, currencies, player templates, shops and content. A build asks for one version by name, so you can prepare the next version while released builds keep reading theirs. Flock gives a new game its first version, named 1.0.0-dev, in the Development environment; find it in Flock under Game Home → Versions, in the Version column.To make another version, press Create Version on that page, then:

Type a Version Name in the form X.Y.Z, such as 1.1.0.
Choose Create New for an empty version, or Inherit and pick a version under Inherit From Version to copy its configs, player templates, shops and items.
For a new version, pick its Release Type (Core for your main line) and its Environment (Development, Pre-Production or Production).
Press Create Version (or Inherit Version). Success: the version appears in the list.

A version deployed to Production is locked: the dashboard then changes it only through a patch. Only studio admins and managers create and deploy versions.

Get your credentials

Your build needs four values. Flock’s Game Home → Getting Started page lists them for the game you have open, under Point the SDK at this game:

Value	Where to find it in Flock
API URL	Flock’s address, `https://api-flock.qwacks.com`. Both engines’ settings already hold it.
API Key	Game Home → API Keys, made as below.
Game Name	The game’s name, as in Game Home → Management (the Game Name field).
Game Version	The version’s name, not its ID, as in Game Home → Versions (the Version column), such as `1.0.0-dev`.

Both engines’ settings ask for the game by its Game Name and for the version by its name.To make the API key:

Open Game Home → API Keys and press Create API Key.
Give it a Name that says where it is used, such as Development Key, and press Create.
API Key Created shows the whole key once. Copy it now: the dashboard never shows it again.

Success: the key is listed with its name, the start of its value and its creation date.The dashboard has no separate development and production keys: every key belongs to the game and works with all of its versions. Make one key per place it is used and name it so, for example Development Key for the editor and test builds and Production Key for released builds. Only studio admins and managers create and revoke keys.

The API Keys page with a Development Key and a Production Key — Game Home → API Keys, with two keys named for where they are used.

Treat your API key like a password and keep it out of public repositories. If one leaks, make a new key, put it in your builds, then press Revoke on the old one and type its name to confirm: every build still using a revoked key stops working at once.

Install and configure the SDK

Add the SDK for your engine — Unity or Unreal — then open its settings (Flock → Settings in Unity, Project Settings → Plugins → Flock SDK Settings in Unreal, where the game is asked for as Game Name) and paste in your credentials. The SDK needs one thing before it can start, the resolved Game Version; a connection check is optional:

Resolve Game Version — looks up your version’s ID and bakes it into the config (writes it into the config in the editor, so every build carries it). Runtime init uses that ID directly and never calls the server, so it must resolve before you play or build. The editor does this automatically as you fill in your credentials.
Verify (optional) — checks that your credentials reach Flock (in Unity, Setup checklist → Verify; in Unreal, Test Connection in the Flock panel, Tools → Flock → Flock Panel). The SDK starts without it.

Success: the version’s ID shows under Resolved Version ID in Unity, or as Game Version Id under Resolved in Unreal.Then choose how the SDK starts:

Automatic (default): with Auto-Initialize On Load (Unity) or Auto Initialize on Load (Unreal) on, the SDK initializes itself before your first scene or level — nothing to call. Reach it through FlockClient.Instance in Unity, or UFlockSubsystem::Get(this) in Unreal.
Manual: turn it off and initialize it yourself — handy to wait for a splash screen or EULA. Unity calls FlockClient.Create(config.ToInitConfig()) (or uses the FlockBootstrap component); Unreal calls InitializeFromSettings().

Full details on the init styles are on the Unity and Unreal SDK pages.

Sign the player in — the SDK manages the session from there.

// A component in your first scene: it signs the player in with an id kept on this device.
using System.Threading.Tasks;
using Flock;
using Flock.Exceptions;
using UnityEngine;

public class FlockSignIn : MonoBehaviour
{
    private async void Start()
    {
        try
        {
            // Flock restores a saved sign-in as it starts: wait for it, and sign in only when nobody is signed in.
            while (FlockClient.IsRestoringSession)
                await Task.Yield();
            if (!FlockClient.Instance.IsAuthenticated)
                await SignInWithThisDeviceAsync();
            Debug.Log($"Signed in as {FlockClient.Instance.CurrentPlayerId}");
        }
        catch (FlockException failed)
        {
            Debug.LogError(failed.Message);   // What is wrong, then a Fix: line.
        }
    }

    private static async Task SignInWithThisDeviceAsync()
    {
        // With no id, both calls use the device id the SDK keeps for this install.
        try
        {
            await FlockClient.Instance.Authentication.LoginWithDeviceAsync();
        }
        catch (FlockException notRegistered) when (notRegistered.ErrorCode == FlockErrorCode.PlayerInvalidLoginCredentials)
        {
            // The first launch on this device: registering creates the player and signs them in.
            await FlockClient.Instance.Authentication.RegisterWithDeviceAsync();
        }
    }
}

// In an actor, with "Flock" in your module's Build.cs.
#include "FlockSubsystem.h"
#include "Providers/FlockAuthProvider.h"
#include "Providers/FlockGameProvider.h"

UFlockSubsystem* Sdk = UFlockSubsystem::Get(this);
if (!Sdk || !Sdk->IsInitialized())
{
    return;   // The Output Log says why Flock did not start, and how to fix it.
}
if (Sdk->IsAuthenticated())
{
    // Signed in already: Flock restored the saved sign-in as it started. A second sign-in would end
    // the session the first one started.
    UE_LOG(LogTemp, Log, TEXT("Signed in as %s"), *Sdk->GetPlayerId());
    return;
}

const TWeakObjectPtr<UFlockSubsystem> WeakSdk(Sdk);

// An empty device ID: the one the SDK makes once and keeps for this install.
Sdk->GetAuthProvider()->RegisterWithDevice(FString(), FString(),
    [WeakSdk](TFlockResult<FFlockRegisterResult> Registered)
    {
        UFlockSubsystem* LiveSdk = WeakSdk.Get();
        if (!LiveSdk)
        {
            return;   // The game is closing.
        }
        if (!Registered.bSuccess)
        {
            UE_LOG(LogTemp, Warning, TEXT("%s"), *Registered.Error.ToDisplayText());   // What is wrong, then a Fix: line.
            return;
        }
        if (!Registered.Value.bAlreadyRegistered)
        {
            UE_LOG(LogTemp, Log, TEXT("Signed in as %s"), *LiveSdk->GetPlayerId());   // A new player, signed in by the register.
            return;
        }
        LiveSdk->GetAuthProvider()->LoginWithDevice(FString(),
            [](TFlockResult<FFlockPlayerLoginResponse> Login)
            {
                if (Login.bSuccess)
                {
                    UE_LOG(LogTemp, Log, TEXT("Signed in as %s"), *Login.Value.PlayerId);
                }
                else
                {
                    UE_LOG(LogTemp, Warning, TEXT("%s"), *Login.Error.ToDisplayText());
                }
            });
    });

In Unreal a device sign-in needs no account screen: check first that nobody is signed in, register the device, and log in only when it already has an account. With the device ID left empty, both calls use the one the SDK keeps for this install (ThisDeviceId(), Flock Get This Device Id in Blueprint). The events that say a player is signed in, the Blueprint way (Flock Is Authenticated, then Flock Register With Device and Flock Login With Device with Device Id left empty), and when to pass an ID of your own are in Your first call. Success is Signed in as and the player’s ID in the Output Log.

Signing in does not create an account — registering is a separate call in both SDKs. Failures surface differently: Unity throws, while Unreal returns a TFlockResult you check, because Unreal builds with exceptions off.

Use a feature

Once a player is signed in, reach any feature through the SDK:

// Inside an async method, once a player is signed in (after the sign-in above, for example).
using Flock;
using Flock.Models;
using UnityEngine;

GameSchema game = await FlockClient.Instance.Game.GetGameAsync();
Debug.Log($"Playing {game.Name}");

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

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

That’s it — you’re live. 🎉

Next steps

Understand authentication

How the SDK manages game and player sessions.

Explore the guides

Players, shops, leaderboards, remote config, and more.

Getting Started

Concepts

Features

Reference

Next steps

Understand authentication

Explore the guides

​Next steps

Understand authentication

Explore the guides

Next steps