Platform login

Guest sessions can be lost when a player closes the game or their browser. To prevent this, you can prompt players to register or sign in on the Jest platform. Registered players are able to receive notifications and won’t risk losing their progress. For more details, see Notifications.

Converting guest players into registered users is one of the most important steps in the user funnel. Improvements at this stage directly translate into higher retention, more active players, and increased revenue.

There are several ways to prompt players to register or sign in, depending on what best fits your game experience. The platform can also automatically trigger prompts, though this behavior can be disabled if needed. See SDK initialization for more information.

The registration flow is completed via SMS or RCS, after which players are seamlessly redirected back into the game.

Platform registration

The platform includes a built-in registration flow that can be triggered directly from your game. It is visually consistent with the rest of the platform and is the easiest option to implement.

This is also the flow used by the platform’s automatic registration prompts.

After initializing the platform, you can trigger the registration flow at the appropriate moment. Only guest players should be prompted to register:

const player = JestSDK.getPlayer();

if (!player.registered) {
  // Guest player — prompt registration
  JestSDK.login();
}

Players can either dismiss the prompt or complete the registration flow. In both cases, no additional handling is required from the game.

The method will throw an error if the player is already registered or if the entry payload is invalid.

The method also supports an optional entryPayload, which is returned to the game after the player completes login:

const player = JestSDK.getPlayer();

if (!player.registered) {
  JestSDK.login({
    entryPayload: {
      source: "after_tutorial",
    },
  });
}

This can be useful for tracking where the registration was initiated or restoring context after the player returns to the game. See Entry payload for more details.

JestSDK.login()

login(options?: {
  entryPayload?: Record<string, unknown>;
}): Promise<void>;

login() returns a promise that resolves once the login popup is dismissed, and resolves immediately if the player is already registered. You can await it to run logic after the player closes the popup:

await JestSDK.login();
// runs after the login popup is dismissed
JestSDK.getPlayer();

Options:

Name	Type	Description
entryPayload	Record<string, unknown>	Optional. The entry payload to pass to the game on login.

Customized registration flow

In addition to the default platform popup, the SDK allows you to build a fully customized registration experience using JestSDK.showRegistrationOverlay(). This approach gives you greater control over the UI and lets you better integrate the flow into your game.

All requirements and functionality remain the same as with the platform registration flow. The key difference is that your game is responsible for rendering and managing the user interface.

The platform will still display the required legal text and provide a dismiss button. This overlay is designed to be minimal, unobtrusive, and visually neutral so it fits naturally within your game.

Once triggered, your game is responsible for handling the rest of the flow, giving you full control over the player experience:

const player = JestSDK.getPlayer();

if (!player.registered) {
  const {
    closeButtonAction,
    loginButtonAction
  } = JestSDK.showRegistrationOverlay();

  // Attach these actions to your in-game UI
}

The method returns two functions:

• closeButtonAction — closes the overlay
• loginButtonAction — initiates the login flow

These should be wired to your in-game buttons or UI elements.

The overlay with legal text and a close button.

The overlay on top of a game.

In addition to entryPayload, the registration overlay supports a theme option, allowing you to match its appearance to your game. The available themes are "dark" (default) and "light".

You can also provide an optional onClose callback, which is triggered when the player dismisses the overlay. This is useful for cleaning up or closing any related game UI.

The callback is invoked both when the built-in close button is used and when closeButtonAction is called, so you don’t need to handle these cases separately:

JestSDK.showRegistrationOverlay({
  theme: "light",
  onClose: () => closeGamePopup(),
});

Custom registration message

When the player taps your login button, their messaging app opens with a message pre-filled. By default it is written in the platform's voice:

I would like to register for Jest. My key is A7K2QP

Pass message to write it in your game's voice instead:

JestSDK.showRegistrationOverlay({
  message: "Let me into Dungeon Crawl! {{registrationCode}} is my code.",
});

The player's messaging app is then pre-filled with:

Let me into Dungeon Crawl! A7K2QP is my code.

Put {{registrationCode}} where you want the code to appear. It is required and must appear exactly once — the platform swaps in a one-time code there, and that code is how the reply is matched back to this player. Leave a space or punctuation around it, because the code is matched as a word of its own.

Keep it under 140 characters so the text the player sends stays a single SMS. Emoji and accented characters re-encode the whole message into less than half the room, so past 70 characters they are dropped from the pre-filled text rather than splitting it into two.

showRegistrationOverlay throws straight away if the message is empty, over the character limit, omits or repeats {{registrationCode}}, contains another {{...}} placeholder, or runs the code into a neighbouring word. Otherwise your text is sent exactly as written, with a full stop added if it doesn't already end in ., ! or ?.

JestSDK.showRegistrationOverlay()

showRegistrationOverlay(
  options?: {
    theme?: "dark" | "light";
    onClose?: () => void;
    entryPayload?: Record<string, unknown>;
    message?: string;
  }
): {
  loginButtonAction: () => void;
  closeButtonAction: () => void;
};

Options:

Name	Type	Description
theme	"dark" | "light"	Optional. The theme of the registration overlay. Defaults to "dark".
onClose	() => void	Optional. Callback function to be executed when the overlay is closed.
entryPayload	Record<string, unknown>	Optional. The entry payload to pass to the game on login.
message	string	Optional. Text the player's messaging app is pre-filled with, in place of the platform's default wording. Must contain {{registrationCode}} once, kept clear of adjacent words, and stay under 140 characters.

Returns:

Name	Type	Description
loginButtonAction	() => void	Function to trigger the login flow from the game UI.
closeButtonAction	() => void	Function to close the overlay from the game UI.