Skip to content


The user module provides various account functionality that you can use to authenticate a user in your game. This means that the CrazyGames players who are logged in on the platform will be able to play games that require a user account without having to register in the game. They will also be logged in automatically in the game on other devices where they use the same CrazyGames account.

The Start here page already familiarized you with the possible SDK scenarios. For the scenarios where authentication is available, please consult the appropriate link below.


Games without user accounts

In this scenario where your game doesn’t have the notion of users, you are not expected to integrate with our user module.

The game should store user data in localStorage (HTML5) or PlayerPrefs/File (Unity). Our APS system will back it up for users logged in to Crazygames.

Standard integration

For this scenario, you should retrieve the user object. You can obtain the username and profile picture from the returned user object, and use them, for example, to greet the user in the game, or display the profile picture. In case the result is null the user is not logged in on CrazyGames and you could trigger an Auth prompt to request them to log in.

You can use the Data module from the HTML5 SDK to store user data, and it will be synced on the user account. The game can also store user data in localStorage (HTML5) or PlayerPrefs/File (Unity), and our APS system will back it up for each logged in user across their devices.

Games with in-game accounts, with a custom back-end

We want to allow a smooth login experience for CrazyGames users, requiring:

  • New logged in CrazyGames users are automatically registered & logged in within your game.
  • Returning logged in CrazyGames users are automatically logged in within your game.
  • CrazyGames guests can play your game as guests if your game supports it.
  • Logging out and other login options (e.g. Facebook, Google) are not allowed and should be removed while playing on CrazyGames.


Your CrazyGames game version will need to allow using CrazyGames user ID's as identifiers within your game. If you are using Firebase, please refer to this section.

At game launch

Start by retrieving the current user. The game should request the current user account every time the game starts.

User is not logged in (getUser() returns null)

You should always allow the user to start playing as Guest.

Optionally, you can give the user the choice:

  • 'Login with CrazyGames' button (triggering our Auth prompt method)
  • Continue as Guest

Please note:

  • Don't allow Guests to use different login methods than 'Login with CrazyGames'
  • Don't trigger the Auth prompt automatically as this might confuse the user
User is logged in on CrazyGames (getUser() returns a user)

Check if the CrazyGames account (via getUserToken()) already exists in your back-end.

  • Case: CrazyGames account is already available:
    • Fetch the data for this user from your back-end, and start playing!
  • Case: The CrazyGames account is not yet known to your game:
    • Automatically create a game account using the player's CrazyGames account, based on the user token. This user will have fresh data in your back-end.

Game login button

You should not display a login page (for example containing external accounts like Google or Facebook). The game should also not allow the user to logout.

You can show a Login button in your menu for Guests, which triggers the same flow as described above in "At game launch".

Players changing CrazyGames accounts while playing

Mandatory for games using In-Game Purchases, optional for other games.

When a user logs out during gameplay, the entire web page is refreshed, so there is nothing else to do in this case. The game flow will start from the beginning.

Users logging into their CrazyGames account while playing can be detected using an auth listener, in this case we will expect you to follow the "User is logged in on CrazyGames" flow above and if necessary refresh the game.

The user module can be accessed like this:



For a demo, please consult the CrazySDK/Demo/UserModule scene. You can run it directly in the Unity editor.

Check availability


The user account functionality is available only when your game is running on CrazyGames domains. It will not work on our partner domains that embed it, or on your whitelisted domains. Before using any user account features, you should always ensure that the user account system is available.

var isAvailable = CrazySDK.User.IsUserAccountAvailable;


If you whitelist your own domain(s) in the CrazyGamesSettings file, and want to know if your game is running per general on CrazyGames domains or our partner websites, you can check it with the following field from CrazySDK. The only place where IsOnCrazyGames is false is on your whitelisted domains.


Get current user


You can retrieve the user currently logged in CrazyGames with the following method:

CrazySDK.User.GetUser(user =>
    if (user != null)
        Debug.Log("Get user result: " + user);
        Debug.Log("User is not logged in");

If the user is not logged in CrazyGames, the returned user will be null.

System info


You can retrieve the system info like this:

var systemInfo = CrazySDK.User.SystemInfo;
// For browser and os, format is the same as
Debug.Log(systemInfo.device); // possible values: "desktop", "tablet", "mobile"

Auth prompt


By calling this method, the log in or register popup will be displayed on CrazyGames. The user can log in their existing account, or create a new account. The method returns the user object.

CrazySDK.User.ShowAuthPrompt((error, user) =>
    if (error != null)
        Debug.LogError("Show auth prompt error: " + error);

    Debug.Log("Auth prompt user: " + user);

The following error codes can be returned:

  • showAuthPromptInProgress - an auth prompt is already opened on the website
  • userAlreadySignedIn - the user is already logged in
  • userCancelled - the user closed the auth prompt without logging in or registering

Get user token


The user token contains the userId of the player that is currently logged in CrazyGames, as well as other useful information (username, profilePictureUrl, etc). You should send it to your server when required, and verify/decode it there to extract the userId. This is useful for linking the user accounts for example, where you can have a column "crazyGamesId" in your user table that will be populated with the user id from the token.

You can retrieve the user token with the following method:

CrazySDK.User.GetUserToken((error, token) =>
    if (error != null)
        Debug.LogError("Get user token error: " + error);

    Debug.Log("User token: " + token);

The token has a lifetime of 1 hour. The method will handle the token refresh. We recommend that you don't store the token, and always call this method when the token is required.

The following error codes can be returned:

  • authNotEnabled - please contact us to enable the user authentication system for your game
  • userNotAuthenticated - the user is not logged in CrazyGames
  • unexpectedError

The returned token can be decoded for testing purposes on

The token payload will contain the following data:

    "userId": "UOuZBKgjwpY9k4TSBB2NPugbsHD3",
    "gameId": "20267",
    "username": "RustyCake.ZU9H",
    "profilePictureUrl": "",
    "iat": 1670328680,
    "exp": 1670332280

When you need to authenticate the requests with your server, you should send the token together with the requests.

The token can be verified with the public key hosted at this URL We recommend that you fetch the key every time you verify the token, since it may change. Alternatively, you can implement a caching mechanism, and re-fetch it when the token fails to decode due to a possible key change.

Here is a TypeScript example that will help you decode and verify the token:

import * as jwt from "jsonwebtoken";
import axios from "axios";

export interface CrazyTokenPayload {
    userId: string;
    gameId: string;
    username: string;
    profilePictureUrl: string;

export const DecodeCGToken = async (
    token: string
): Promise<CrazyTokenPayload> => {
    let key = "";

    try {
        const resp = await axios.get(
        key =["publicKey"];
    } catch (e) {
        console.error("Failed to fetch CrazyGames public key", e);

    if (!key) {
        throw new Error("Key is empty when decoding CrazyGames token");

    const payload = jwt.verify(token, key, { algorithms: ["RS256"] });
    return payload as CrazyTokenPayload;

Auth listener


You can register user auth listeners that are triggered when the player logs in CrazyGames. A log out doesn't trigger the auth listeners, since the entire page is refreshed when the player logs out.

Action<PortalUser> lst = (user) => { Debug.Log("Auth listener, user: " + user); };
CrazySDK.User.AddAuthListener(lst); // add
CrazySDK.User.RemoveAuthListener(lst); // remove (for example on scene change)

After detecting a login using the Auth Listener, if you use the CrazyGames account as an identifier you should fetch the user's progress from your back-end.

If you rely on the CrazyGames automatic progress save, our system automatically reloads the game in case of a login.

Saving user data


By default, our APS system automatically backs up player data (PlayerPrefs, and the provided file name if present). The automatic backup isn't always the best solution, since we cannot reliably detect if any IndexedDB changes occur. That's why we also provide the SyncUnityGameData that you can manually call to ensure the player data is saved at the opportune moments.


For more details, please check the APS page.



If you are using Firebase, account linking shouldn't be done client side. This is a security risk since anyone can inject any user id in the SDK. To implement account linking correctly with Firebase, you should use Cloud Functions with Firestore or Real Time Database. Integration suggestion:

  • send the token obtained from the CrazyGames SDK to a cloud function
  • the cloud function should parse and verify the token, and then create a new document in the database linking the CrazyGames user id obtained from the token to your user id
  • the cloud function creates a custom Firebase token and returns it back, and you use it to authenticate in Firebase
  • for future requests, the cloud function will check if there is any document linking the CrazyGames user id to your user id, and return the custom firebase token

We will release a more comprehensive guide about Firebase later.


If you'd like to keep other sign in providers (Google or Facebook for example), you'll need to handle account linking between the CrazyGames account and the other providers. Check User linking page to find out more about user account linking.

For requesting the user's permission to link their CrazyGames account to the in-game account, please use the provided account link modal and avoid implementing it yourself. This provides the players with a standard modal, and also allows them to select the "Always link accounts" option (coming soon).

Account link modal

You can display the modal by calling the following method:

CrazySDK.User.ShowAccountLinkPrompt((error, answer) =>
    if (error != null)
        Debug.LogError("Show account link prompt error: " + error);

    Debug.Log("Account link answer: " + answer);

The answer will be true if the player agrees to link the accounts, and false otherwise.

The following error codes can be returned:

  • showAccountLinkPromptInProgress - the link account modal is already displayed
  • userNotAuthenticated - the user is not logged in CrazyGames




When you are running the game in the editor, the method calls will return some hard-coded values.

You can customize the returned values in the CrazySDK/Resources/CrazyGamesSettings object:


In the above image, you can also see the default values returned by the methods.

QA Tool

When previewing the game in the QA tool, you can customize the returned values with the following modal:

QA tool fake user modal