Unreal Reference

The SpacetimeDB client for Unreal Engine contains all the tools you need to build native clients for SpacetimeDB modules using C++ and Blueprint.

Before diving into the reference, you may want to review:

• Generating Client Bindings - How to generate Unreal bindings from your module
• Connecting to SpacetimeDB - Establishing and managing connections
• SDK API Reference - Core concepts that apply across all SDKs

Name	Description
Project setup	Configure an Unreal project to use the SpacetimeDB Unreal client SDK.
Generate module bindings	Use the SpacetimeDB CLI to generate module-specific types and interfaces.
DbConnection type	A connection to a remote database.
Context interfaces	Context objects for interacting with the remote database in callbacks.
Access the client cache	Access to your local view of the database.
Observe and invoke reducers	Send requests to the database to run reducers, and register callbacks for reducer results on the calling connection.
Subscriptions	Subscribe to queries and manage subscription lifecycle.
Query Builder API	Build typed subscription queries in Unreal C++ and Blueprint.
Identify a client	Types for identifying users and client connections.

Project setup

Using the Unreal Engine Plugin

Add the SpacetimeDB Unreal SDK to your project as a plugin. The SDK provides both C++ and Blueprint APIs for connecting to SpacetimeDB modules.

Generate module bindings

Each SpacetimeDB client depends on some bindings specific to your module. Generate the Unreal interface files using the Spacetime CLI. From your project directory, run:

spacetime generate --lang unrealcpp --uproject-dir <uproject_directory> --module-path <module_path> --unreal-module-name <module_name>

Replace:

• <uproject_directory> with the path to your Unreal project directory (containing the .uproject file)
• <module_path> with the path to your SpacetimeDB module
• <module_name> with the name of your Unreal module, typically the name of the project

Example:

spacetime generate --lang unrealcpp --uproject-dir /path/to/MyGame --module-path /path/to/quickstart-chat --unreal-module-name QuickstartChat

This generates module-specific bindings in your project's ModuleBindings directory.

Type DbConnection

A connection to a remote database is represented by the UDbConnection class. This class is generated per module and contains information about the types, tables, and reducers defined by your module.

Name	Description
Connect to a database	Construct a UDbConnection instance.
Advance the connection	Process queued WebSocket messages and dispatch callbacks.
Access tables and reducers	Access the client cache, request reducer invocations, and register callbacks.

Connect to a database

class UDbConnection
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    static UDbConnectionBuilder* Builder();
};

Construct a UDbConnection by calling UDbConnection::Builder(), chaining configuration methods, and finally calling .Build(). At a minimum, you must specify WithUri to provide the URI of the SpacetimeDB instance, and WithDatabaseName to specify the database's name or identity.

Name	Description
WithUri method	Set the URI of the SpacetimeDB instance hosting the remote database.
WithDatabaseName method	Set the name or identity of the remote database.
WithToken method	Supply a token to authenticate with the remote database.
WithCompression method	Set the compression method for WebSocket communication.
OnConnect callback	Register a callback to run when the connection is successfully established.
OnConnectError callback	Register a callback to run if the connection is rejected or the host is unreachable.
OnDisconnect callback	Register a callback to run when the connection ends.
Build method	Finalize configuration and open the connection.

Method WithUri

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnectionBuilder* WithUri(const FString& InUri);
};

Configure the URI of the SpacetimeDB instance or cluster which hosts the remote module and database.

Method WithDatabaseName

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnectionBuilder* WithDatabaseName(const FString& InName);
};

Configure the SpacetimeDB domain name or Identity of the remote database which identifies it within the SpacetimeDB instance or cluster.

Method WithToken

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnectionBuilder* WithToken(const FString& InToken);
};

Chain a call to .WithToken(token) to your builder to provide an OpenID Connect compliant JSON Web Token to authenticate with, or to explicitly select an anonymous connection.

Method WithCompression

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnectionBuilder* WithCompression(const ESpacetimeDBCompression& InCompression);
};

Set the compression method for WebSocket communication. Available options:

• ESpacetimeDBCompression::None - No compression
• ESpacetimeDBCompression::Gzip - Gzip compression (default)
• ESpacetimeDBCompression::Brotli - Brotli compression (not implemented, defaults to Gzip)

Callback OnConnect

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnectionBuilder* OnConnect(FOnConnectDelegate Callback);
};

Chain a call to .OnConnect(callback) to your builder to register a callback to run when your new UDbConnection successfully initiates its connection to the remote database. The callback accepts three arguments: a reference to the UDbConnection, the FSpacetimeDBIdentity by which SpacetimeDB identifies this connection, and a private access token which can be saved and later passed to WithToken to authenticate the same user in future connections.

Callback OnConnectError

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnectionBuilder* OnConnectError(FOnConnectErrorDelegate Callback);
};

Chain a call to .OnConnectError(callback) to your builder to register a callback to run when your connection fails.

Callback OnDisconnect

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnectionBuilder* OnDisconnect(FOnDisconnectDelegate Callback);
};

Chain a call to .OnDisconnect(callback) to your builder to register a callback to run when your UDbConnection disconnects from the remote database, either as a result of a call to Disconnect or due to an error.

Method Build

class UDbConnectionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    UDbConnection* Build();
};

Finalize configuration and open the connection. This creates a WebSocket connection to ws://<uri>/v1/database/<database>/subscribe?compression=<compression> and begins processing messages using the Unreal SDK's binary v2 WebSocket subprotocol.

Advance the connection and process messages

The Unreal SDK receives WebSocket messages asynchronously, then queues them for processing on the game thread. You must either call FrameTick() regularly, typically from an Actor's Tick(), or enable automatic ticking once with SetAutoTicking(true). Without one of these, queued messages are not processed and table callbacks, reducer callbacks, and subscription callbacks will not fire.

You can either call FrameTick() yourself from an Actor or component tick, or enable the SDK's automatic ticker once after building the connection:

void AGameManager::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    if (Conn && Conn->IsActive())
    {
        Conn->FrameTick();
    }
}

Conn = Builder->Build();
Conn->SetAutoTicking(true);

Method FrameTick

class UDbConnection
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    void FrameTick();
};

Process any queued server messages and dispatch the corresponding callbacks. Call this regularly from game-thread code if you manage ticking yourself.

Method SetAutoTicking

class UDbConnection
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    void SetAutoTicking(bool bAutoTick);
};

Enable or disable the SDK's automatic ticker. When enabled, the connection registers with Unreal's core ticker and calls FrameTick() for you.

Access tables and reducers

class UDbConnection
{
    UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
    URemoteTables* Db;

    UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
    URemoteReducers* Reducers;
};

The Db property provides access to the client cache, and the Reducers property allows invoking reducers and handling the results of reducers called by this connection.

Context interfaces

Context objects provide access to the database and reducers within callback functions. All context types inherit from FContextBase.

Name	Description
FContextBase	Base context providing access to Db and Reducers.
FEventContext	Context for table row event callbacks.
FReducerEventContext	Context for reducer event callbacks.
FSubscriptionEventContext	Context for subscription lifecycle callbacks.
FErrorContext	Context for error callbacks.

Type FContextBase

USTRUCT(BlueprintType)
struct FContextBase
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadOnly, Category = "SpacetimeDB")
    URemoteTables* Db;

    UPROPERTY(BlueprintReadOnly, Category = "SpacetimeDB")
    URemoteReducers* Reducers;

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    USubscriptionBuilder* SubscriptionBuilder();

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    bool TryGetIdentity(FSpacetimeDBIdentity& OutIdentity) const;

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    FSpacetimeDBConnectionId GetConnectionId() const;
};

Base context providing access to the client cache, reducers, subscription builder, and connection information.

Type FEventContext

USTRUCT(BlueprintType)
struct FEventContext : public FContextBase
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
    FSpacetimeDBEvent Event;
};

Context passed to table row event callbacks (OnInsert, OnUpdate, OnDelete).

Type FReducerEventContext

USTRUCT(BlueprintType)
struct FReducerEventContext : public FContextBase
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
    FReducerEvent Event;
};

Context passed to reducer event callbacks, containing information about the reducer execution.

Type FSubscriptionEventContext

USTRUCT(BlueprintType)
struct FSubscriptionEventContext : public FContextBase
{
    GENERATED_BODY()
};

Context passed to subscription lifecycle callbacks (OnApplied, OnError).

Type FErrorContext

USTRUCT(BlueprintType)
struct FErrorContext : public FContextBase
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadOnly, Category="SpacetimeDB")
    FString Error;
};

Context passed to error callbacks, containing error information.

Access the client cache

All context types provide access to the client cache through the .Db property, which contains generated table classes for each table defined by your module.

Each table defined by a module has a corresponding generated class (e.g., UUserTable, UMessageTable) that inherits from URemoteTable and provides methods for accessing subscribed rows.

Name	Description
URemoteTable	Base class for all generated table classes.
Unique constraint index access	Seek a subscribed row by the value in its unique or primary key column.
BTree index access	Seek subscribed rows by the value in its indexed column.

Type URemoteTable

Generated table classes inherit from URemoteTable and provide the following interface:

Name	Description
Count method	The number of subscribed rows in the table.
Iter method	Iterate over all subscribed rows in the table.
OnInsert callback	Register a callback to run whenever a row is inserted into the client cache.
OnDelete callback	Register a callback to run whenever a row is deleted from the client cache.
OnUpdate callback	Register a callback to run whenever a subscribed row is replaced with a new version.

Method Count

UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
int32 Count() const;

The number of rows of this table resident in the client cache, i.e. the total number which match any subscribed query.

Method Iter

UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
TArray<RowType> Iter() const;

An iterator over all the subscribed rows in the client cache, i.e. those which match any subscribed query.

Callback OnInsert

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FOnTableInsert,
    const FEventContext&, Context,
    const RowType&, NewRow);

UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
FOnTableInsert OnInsert;

The OnInsert callback runs whenever a new row is inserted into the client cache, either when applying a subscription or being notified of a transaction.

Callback OnDelete

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FOnTableDelete,
    const FEventContext&, Context,
    const RowType&, DeletedRow);

UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
FOnTableDelete OnDelete;

The OnDelete callback runs whenever a previously-resident row is deleted from the client cache.

Callback OnUpdate

DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(
    FOnTableUpdate,
    const FEventContext&, Context,
    const RowType&, OldRow,
    const RowType&, NewRow);

UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
FOnTableUpdate OnUpdate;

The OnUpdate callback runs whenever an already-resident row in the client cache is updated, i.e. replaced with a new row that has the same primary key.

Unique constraint index access

For each unique constraint on a table, its table class has a property which is a unique index handle. This unique index handle has a method .Find(Column value). If a Row with value in the unique column is resident in the client cache, .Find returns it. Otherwise it returns null.

Example

Given the following module-side User definition:

USTRUCT()
struct FUserType
{
    GENERATED_BODY()

    UPROPERTY()
    FSpacetimeDBIdentity Identity; // Unique constraint
    // ... other fields
};

a client would lookup a user as follows:

FUserType* FindUser(URemoteTables* Tables, FSpacetimeDBIdentity Id)
{
    return Tables->User->Identity->Find(Id);
}

BTree index access

For each btree index defined on a remote table, its corresponding table class has a property which is a btree index handle. This index handle has a method TArray<RowType> Filter(Column value) which will return Rows with value in the indexed Column, if there are any in the cache.

Example

Given the following module-side Player definition:

USTRUCT()
struct FPlayerType
{
    GENERATED_BODY()

    UPROPERTY()
    FSpacetimeDBIdentity Id; // Primary key

    UPROPERTY()
    uint32 Level; // BTree index
    // ... other fields
};

a client would count the number of Players at a certain level as follows:

int32 CountPlayersAtLevel(URemoteTables* Tables, uint32 Level)
{
    return Tables->Player->Level->Filter(Level).Num();
}

Observe and invoke reducers

All context types provide access to reducers through the .Reducers property, which contains generated methods for invoking reducers defined by the module and generated delegates for reducer results.

Each reducer defined by the module has methods on the .Reducers:

• An invoke method, whose name matches the reducer's name (e.g., SendMessage, SetName). This requests that the module run the reducer.
• A generated delegate, whose name is prefixed with On (e.g., OnSendMessage, OnSetName). This runs when the result for a reducer call made by this connection is received and correlated by request_id.

Invoke reducers

class URemoteReducers
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    void SendMessage(const FString& Text);

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    void SetName(const FString& Name);
};

Observe reducer results

class URemoteReducers
{
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
        FOnSendMessage,
        const FReducerEventContext&, Context,
        const FString&, Text);

    UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
    FOnSendMessage OnSendMessage;

    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
        FOnSetName,
        const FReducerEventContext&, Context,
        const FString&, Name);

    UPROPERTY(BlueprintAssignable, Category = "SpacetimeDB Events")
    FOnSetName OnSetName;
};

The generated On<Reducer> delegates are the Unreal equivalent of a per-call callback. They are not global reducer broadcasts for other clients' reducer calls.

Subscriptions

Create subscriptions to receive updates for specific queries using the USubscriptionBuilder and USubscriptionHandle classes.

For Unreal C++, the recommended default is to build subscriptions with AddQuery(...) and then call parameterless Subscribe(). Raw SQL subscriptions remain available when you need to provide SQL directly.

Name	Description
USubscriptionBuilder	Build and configure subscriptions.
USubscriptionHandle	Manage subscription lifecycle.

Type USubscriptionBuilder

class USubscriptionBuilder
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    USubscriptionBuilder* OnApplied(FOnSubscriptionApplied Callback);

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    USubscriptionBuilder* OnError(FOnSubscriptionError Callback);

    USubscriptionBuilder* AddQuery(TFunctionRef<FQuery(const FQueryBuilder&)> BuildQuery);

    UFUNCTION(BlueprintCallable, Category="SpacetimeDB")
    USubscriptionHandle* Subscribe();

    UFUNCTION(BlueprintCallable, Category="SpacetimeDB")
    USubscriptionHandle* Subscribe(const TArray<FString>& SQL);

    UFUNCTION(BlueprintCallable, Category="SpacetimeDB")
    USubscriptionHandle* SubscribeToAllTables();
};

Method OnApplied

USubscriptionBuilder* OnApplied(FOnSubscriptionApplied Callback);

Register a callback to run when the subscription is successfully applied.

Method OnError

USubscriptionBuilder* OnError(FOnSubscriptionError Callback);

Register a callback to run if the subscription fails.

Method AddQuery

USubscriptionBuilder* AddQuery(TFunctionRef<FQuery(const FQueryBuilder&)> BuildQuery);

Append a typed query to the builder. The callback receives an FQueryBuilder, typically named Q, and returns a generated query source or filtered query. Call AddQuery(...) once per table or view query you want to subscribe to, then finish with parameterless Subscribe().

Method Subscribe

USubscriptionHandle* Subscribe();

Subscribe to the typed queries accumulated with AddQuery(...) and return a handle for managing the subscription.

Method Subscribe (SQL overload)

USubscriptionHandle* Subscribe(const TArray<FString>& SQL);

Subscribe to the provided SQL queries and return a handle for managing the subscription. Use this when you need to write SQL directly instead of using the typed query builder.

Method SubscribeToAllTables

USubscriptionHandle* SubscribeToAllTables();

Subscribe to all public tables in the module.

SubscribeToAllTables() is useful for quick prototypes and small modules. Prefer typed queries for production subscriptions so the subscription set stays explicit.

Type USubscriptionHandle

class USubscriptionHandle
{
    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    void Unsubscribe();

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    void UnsubscribeThen(FSubscriptionEventDelegate OnEnd);

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    bool IsEnded() const;

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    bool IsActive() const;

    UFUNCTION(BlueprintCallable, Category = "SpacetimeDB")
    TArray<FString> GetQuerySqls() const;
};

Method Unsubscribe

void Unsubscribe();

Immediately cancel the subscription.

Method UnsubscribeThen

void UnsubscribeThen(FSubscriptionEventDelegate OnEnd);

Cancel the subscription and invoke the provided callback when complete.

Method IsEnded

bool IsEnded() const;

True once the subscription has ended.

Method IsActive

bool IsActive() const;

True while the subscription is active.

Method GetQuerySqls

TArray<FString> GetQuerySqls() const;

Get the SQL queries associated with this subscription.

Query Builder API

Use the Unreal query builder to build typed subscriptions in C++ and Blueprint.

In C++, a query typically starts from the generated FQueryBuilder passed to AddQuery(...), selects a source from Q.From, and optionally applies Where(...) with generated column objects:

USubscriptionHandle* Handle = Conn->SubscriptionBuilder()
    ->OnApplied(FOnSubscriptionApplied::CreateUObject(this, &AMyActor::OnSubscriptionApplied))
    ->OnError(FOnSubscriptionError::CreateUObject(this, &AMyActor::OnSubscriptionError))
    ->AddQuery([](const FQueryBuilder& Q)
    {
        return Q.From.Player().Where([](const FPlayerCols& Cols)
        {
            return Cols.Level.Gte(1).And(Cols.DisplayName.Neq(TEXT("Guest")));
        });
    })
    ->Subscribe();

The generated query-builder surface is module-specific. Sources, column sets, and query return types are generated from your schema and views.

Query sources

Each public table or subscribed query source is available under Q.From using a generated method:

Q.From.Player()
Q.From.ActivePlayerLocations()
Q.From.PlayersAtLevel0()

Event tables are not subscribed implicitly. Subscribe to them with an explicit query just like any other source:

Conn->SubscriptionBuilder()
    ->AddQuery([](const FQueryBuilder& Q)
    {
        return Q.From.DamageEvent();
    })
    ->Subscribe();

Predicates

Generated column objects expose typed predicate methods such as:

• Eq
• Neq
• Gt
• Lt
• Gte
• Lte

Predicates can be combined with:

• And
• Or
• Not

Example:

Conn->SubscriptionBuilder()
    ->AddQuery([](const FQueryBuilder& Q)
    {
        return Q.From.Player().Where([](const FPlayerCols& Cols)
        {
            return Cols.Level.Gte(3).And(Cols.IsOnline.Eq(true));
        });
    })
    ->AddQuery([](const FQueryBuilder& Q)
    {
        return Q.From.ActivePlayerLocations().Where([](const FActivePlayerLocationsCols& Cols)
        {
            return Cols.X.Gte(10).And(Cols.Y.Lte(400));
        });
    })
    ->Subscribe();

Blueprint availability

The Unreal query builder is available in both C++ and Blueprint.

In Blueprint, generated nodes expose the same overall flow:

• source query nodes
• column nodes
• predicate nodes
• Where
• AddQuery
• Subscribe

Blueprint uses generated source-specific query types for authoring and converts them at the AddQuery boundary automatically.

For example, a Blueprint subscription to online players at level 3 or higher would follow this node flow:

From Player
├─> Player Level
│   └─> Int32 Greater Equal (3)
├─> Player IsOnline
│   └─> Bool Equal (true)
└─> Player Where
    └─> AND
        ├─> Int32 Greater Equal (3)
        └─> Bool Equal (true)

Player Where
└─> AddQuery
    └─> Subscribe

The exact node names are generated from your schema, so Player, Level, and IsOnline will vary by module.

Notes and limitations

• OnApplied is the right place to inspect the initial subscribed result set in the client cache.
• OnInsert, OnUpdate, and OnDelete are for subsequent live changes after the subscription is active.
• TimeDuration query predicates are currently unsupported.
• Raw SQL subscriptions remain available when you need manual SQL control.

Identify a client

Type FSpacetimeDBIdentity

A unique public identifier for a client connected to a database. This is a 256-bit value.

USTRUCT(BlueprintType, Category = "SpacetimeDB")
struct FSpacetimeDBIdentity
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FSpacetimeDBUInt256 Value;

    // Comparison operators, constructors, etc.
};

Type FSpacetimeDBConnectionId

An opaque identifier for a client connection to a database, intended to differentiate between connections from the same Identity. This is a 128-bit value.

USTRUCT(BlueprintType, Category = "SpacetimeDB")
struct FSpacetimeDBConnectionId
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FSpacetimeDBUInt128 Value;

    // Comparison operators, constructors, etc.
};

Type FSpacetimeDBTimestamp

A point in time, measured in microseconds since the Unix epoch.

USTRUCT(BlueprintType, Category = "SpacetimeDB")
struct FSpacetimeDBTimestamp
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int64 MicrosSinceEpoch;

    // Comparison operators, constructors, etc.
};

Example usage

Here's a complete example of connecting to SpacetimeDB, subscribing with the typed query builder, and handling events:

// In your Actor's BeginPlay()
void AMyActor::BeginPlay()
{
    Super::BeginPlay();

    // Setup connection callbacks
    FOnConnectDelegate ConnectDelegate;
    BIND_DELEGATE_SAFE(ConnectDelegate, this, AMyActor, OnConnected);

    FOnDisconnectDelegate DisconnectDelegate;
    BIND_DELEGATE_SAFE(DisconnectDelegate, this, AMyActor, OnDisconnected);

    // Build and connect
    Conn = UDbConnection::Builder()
        ->WithUri(TEXT("127.0.0.1:3000"))
        ->WithDatabaseName(TEXT("my-module"))
        ->OnConnect(ConnectDelegate)
        ->OnDisconnect(DisconnectDelegate)
        ->Build();

    // Register table callbacks
    Conn->Db->User->OnInsert.AddDynamic(this, &AMyActor::OnUserInsert);
    Conn->Db->User->OnUpdate.AddDynamic(this, &AMyActor::OnUserUpdate);
    Conn->Db->User->OnDelete.AddDynamic(this, &AMyActor::OnUserDelete);

    // Register reducer result callbacks for calls made by this connection
    Conn->Reducers->OnSendMessage.AddDynamic(this, &AMyActor::OnSendMessage);
}

void AMyActor::OnConnected(UDbConnection* Connection, FSpacetimeDBIdentity Identity, const FString& Token)
{
    // Save token for future connections
    UCredentials::SaveToken(Token);

    // Subscribe with typed queries
    USubscriptionHandle* Handle = Connection->SubscriptionBuilder()
        ->OnApplied(FOnSubscriptionApplied::CreateUObject(this, &AMyActor::OnSubscriptionApplied))
        ->OnError(FOnSubscriptionError::CreateUObject(this, &AMyActor::OnSubscriptionError))
        ->AddQuery([](const FQueryBuilder& Q)
        {
            return Q.From.User();
        })
        ->AddQuery([](const FQueryBuilder& Q)
        {
            return Q.From.Message().Where([](const FMessageCols& Cols)
            {
                return Cols.ChannelId.Eq(1);
            });
        })
        ->Subscribe();
}

void AMyActor::OnUserInsert(const FEventContext& Context, const FUserType& NewRow)
{
    UE_LOG(LogTemp, Log, TEXT("User inserted: %s"), *NewRow.Name);
}

void AMyActor::OnSendMessage(const FReducerEventContext& Context, const FString& Text)
{
    UE_LOG(LogTemp, Log, TEXT("Message sent: %s"), *Text);
}

void AMyActor::SendMessage(const FString& Text)
{
    if (Conn && Conn->Reducers)
    {
        Conn->Reducers->SendMessage(Text);
    }
}

void AMyActor::OnDisconnected(UDbConnection* Connection, const FString& Error)
{
    UE_LOG(LogTemp, Warning, TEXT("Disconnected from SpacetimeDB: %s"), *Error);
}

For small modules or quick debugging sessions, you can still subscribe to every public table:

USubscriptionHandle* Handle = Conn->SubscriptionBuilder()
    ->OnApplied(FOnSubscriptionApplied::CreateUObject(this, &AMyActor::OnSubscriptionApplied))
    ->SubscribeToAllTables();