Initialize the SDK, create and login players, distribute coins, open the store, and check balances

Core Usage

This page covers the essential SDK methods you will call in every integration — from initialization to opening the store. Follow the steps in order.

1. Initialize the SDK

Add using PlaySuperUnity; at the top of your script, then call Initialize in Awake so the SDK is ready before any scene logic runs:

using PlaySuperUnity;

void Awake()
{
    // Production
    PlaySuperUnitySDK.Initialize("YOUR_API_KEY");

    // Development — points the SDK to the dev environment
    PlaySuperUnitySDK.Initialize("YOUR_API_KEY", isDev: true);
}

Parameter	Type	Default	Description
`apiKey`	`string`	—	Your game's API key from the PlaySuper console (required)
`isDev`	`bool`	`false`	Set to `true` to use the development environment (`dev.playsuper.club`). Use `false` (or omit) for production.

Use isDev: true during development and testing. When you are ready to go live, remove the flag or set it to false so the SDK connects to the production environment.

If you regenerate your API key in the console, update the key in your code immediately — they must match.

Place the Initialize call in a top-level script attached to a GameObject in your first scene. This ensures the SDK persists across scene changes.

2. Create a player

Before you can distribute coins, register the player with PlaySuper. Call CreatePlayerWithUuid once per player, passing your game's internal user ID:

async void CreatePlayer()
{
    string playerUuid = "your-unique-player-id";

    var response = await PlaySuperUnitySDK.Instance.CreatePlayerWithUuid(playerUuid);

    if (response != null && response.data != null)
    {
        Debug.Log($"Player created with ID: {response.data.playerId}");
    }
    else
    {
        Debug.LogError("Failed to create player");
    }
}

Parameter	Type	Description
`uuid`	`string`	Your game's unique identifier for this player (required)

You only need to create a player once. Store the UUID and reuse it for login on subsequent sessions.

3. Log the player in

After the player exists, authenticate them with LoginFederatedByStudio. The SDK stores the auth token automatically and uses it for all subsequent calls:

async void LoginPlayer()
{
    string playerUuid = "your-unique-player-id";

    var response = await PlaySuperUnitySDK.Instance.LoginFederatedByStudio(playerUuid);

    if (response != null && !string.IsNullOrEmpty(response.access_token))
    {
        Debug.Log("Player logged in successfully!");
    }
    else
    {
        Debug.LogError("Failed to login player");
    }
}

Parameter	Type	Description
`uuid`	`string`	The same UUID used in `CreatePlayerWithUuid` (required)

The auth token persists across sessions until it expires. On each launch, check IsLoggedIn() and re-login only if it returns false.

async void Start()
{
    if (!PlaySuperUnitySDK.IsLoggedIn())
    {
        await PlaySuperUnitySDK.Instance.LoginFederatedByStudio(playerUuid);
    }

    // Ready to distribute coins and open the store
}

4. Distribute coins

Once the player is logged in, award coins whenever they perform a rewarded action. Get the coinId from the Coins page in the console:

async void DistributeCoins()
{
    string coinId = "YOUR_COIN_ID";
    int amount = 100;

    await PlaySuperUnitySDK.Instance.DistributeCoins(coinId, amount);
    Debug.Log($"Distributed {amount} coins");
}

Parameter	Type	Description
`coinId`	`string`	The coin ID from the PlaySuper console (required)
`amount`	`int`	Number of coins to award (required)

If the player is offline or not yet logged in, the SDK queues the transaction locally and syncs it automatically once connectivity and authentication are restored.

5. Open the store

Let the player browse and redeem rewards by opening the PlaySuper store. The store uses the stored auth token automatically:

void OpenStore()
{
    PlaySuperUnitySDK.Instance.OpenStore();
}

You can also deep-link to a specific store page or add UTM tracking:

// Open directly to the rewards section
PlaySuperUnitySDK.Instance.OpenStore("https://store.playsuper.club/rewards");

// Open with UTM tracking
PlaySuperUnitySDK.Instance.OpenStore("https://store.playsuper.club/gcommerce", "main_menu_button");

Parameter	Type	Description
`url`	`string`	Optional — a specific store page to open
`utmContent`	`string`	Optional — UTM content tag for analytics

Before critical operations, verify the player is still authenticated:

bool isLoggedIn = PlaySuperUnitySDK.IsLoggedIn();

The token is stored locally and survives app restarts. If IsLoggedIn() returns false, call LoginFederatedByStudio again to refresh it.

7. Get the player's coin balance

Retrieve all coin balances for the current player:

PlaySuperUnitySDK.Instance.GetBalance((List<CoinBalance> balances) => {
    foreach (CoinBalance balance in balances)
    {
        Debug.Log($"Coin: {balance.name}, Amount: {balance.amount}");
    }
});

Property	Type	Description
`id`	`string`	Coin ID
`name`	`string`	Coin name
`url`	`string`	Coin image URL
`amount`	`int`	Current balance

Next, learn how to handle the store close event across platforms in Store Close Handling.

Core Usage

On this page