Onboarding

Go from signup to live games in three phases. Each phase builds on the previous one, and you can start exploring immediately after receiving your credentials.

What You Receive

During onboarding, we provision your account and send you:

Item	Description
Operator ID	Your unique UUID, used in the `X-Operator-ID` header on every request
HMAC Secret	Server-generated shared secret for request signing
Staging access	Base URL and docs for the staging environment

You can optionally provide these at any point during onboarding:

Item	Description
Callback base URL	Where the RGS sends wallet requests (staging URL is fine to start)
Geo-restrictions	Countries or regions where your games should be available
Lobby URL	Where to redirect players after a game session ends

None of these are required to get started. You can provide or update them at any time.

Integration Phases

Explore with Demo Mode

With just your operator ID and HMAC secret, you can call the API right away. No callbacks needed yet.

List available games:

SECRET="your-hmac-secret"
TIMESTAMP=$(date +%s)
PATH_="/operator/games"
SIG=$(echo -n "${TIMESTAMP}${PATH_}" | openssl dgst -sha256 -hmac "$SECRET" | awk '{print $2}')

curl https://rgs-staging.jackpot.studio/operator/games \
  -H "X-Operator-ID: your-operator-uuid" \
  -H "X-Timestamp: $TIMESTAMP" \
  -H "X-HMAC-SHA256: $SIG"

const crypto = require("crypto");

const operatorId = "your-operator-uuid";
const secret = "your-hmac-secret";
const timestamp = Math.floor(Date.now() / 1000).toString();
const path = "/operator/games";

const signature = crypto
  .createHmac("sha256", secret)
  .update(timestamp + path)
  .digest("hex");

const resp = await fetch("https://rgs-staging.jackpot.studio/operator/games", {
  headers: {
    "X-Operator-ID": operatorId,
    "X-Timestamp": timestamp,
    "X-HMAC-SHA256": signature,
  },
});

timestamp := strconv.FormatInt(time.Now().Unix(), 10)
path := "/operator/games"

mac := hmac.New(sha256.New, []byte("your-hmac-secret"))
mac.Write([]byte(timestamp))
mac.Write([]byte(path))
signature := hex.EncodeToString(mac.Sum(nil))

req, _ := http.NewRequest("GET",
    "https://rgs-staging.jackpot.studio/operator/games", nil)
req.Header.Set("X-Operator-ID", "your-operator-uuid")
req.Header.Set("X-Timestamp", timestamp)
req.Header.Set("X-HMAC-SHA256", signature)

import hmac, hashlib, time, requests

operator_id = "your-operator-uuid"
secret = "your-hmac-secret"
timestamp = str(int(time.time()))
path = "/operator/games"

signature = hmac.new(
    secret.encode(), (timestamp + path).encode(), hashlib.sha256
).hexdigest()

resp = requests.get(
    "https://rgs-staging.jackpot.studio/operator/games",
    headers={
        "X-Operator-ID": operator_id,
        "X-Timestamp": timestamp,
        "X-HMAC-SHA256": signature,
    },
)

Launch a demo game by adding "demo": true to a launch request. Demo mode uses a virtual balance so you can see the full game experience without implementing any callbacks.

BODY='{"playerId":"test-player","currency":"USD","gameCode":"dice-alpha","countryCode":"US","demo":true}'
SECRET="your-hmac-secret"
TIMESTAMP=$(date +%s)
PATH_="/operator/launch"
SIG=$(echo -n "${TIMESTAMP}${PATH_}${BODY}" | openssl dgst -sha256 -hmac "$SECRET" | awk '{print $2}')

curl -X POST https://rgs-staging.jackpot.studio/operator/launch \
  -H "Content-Type: application/json" \
  -H "X-Operator-ID: your-operator-uuid" \
  -H "X-Timestamp: $TIMESTAMP" \
  -H "X-HMAC-SHA256: $SIG" \
  -d "$BODY"

const crypto = require("crypto");

const operatorId = "your-operator-uuid";
const secret = "your-hmac-secret";
const body = JSON.stringify({
  playerId: "test-player",
  currency: "USD",
  gameCode: "dice-alpha",
  countryCode: "US",
  demo: true,
});
const timestamp = Math.floor(Date.now() / 1000).toString();
const path = "/operator/launch";

const signature = crypto
  .createHmac("sha256", secret)
  .update(timestamp + path + body)
  .digest("hex");

const resp = await fetch("https://rgs-staging.jackpot.studio/operator/launch", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-Operator-ID": operatorId,
    "X-Timestamp": timestamp,
    "X-HMAC-SHA256": signature,
  },
  body,
});

body, _ := json.Marshal(map[string]any{
    "playerId":    "test-player",
    "currency":    "USD",
    "gameCode":    "dice-alpha",
    "countryCode": "US",
    "demo":        true,
})
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
path := "/operator/launch"

mac := hmac.New(sha256.New, []byte("your-hmac-secret"))
mac.Write([]byte(timestamp))
mac.Write([]byte(path))
mac.Write(body)
signature := hex.EncodeToString(mac.Sum(nil))

req, _ := http.NewRequest("POST",
    "https://rgs-staging.jackpot.studio/operator/launch",
    bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-Operator-ID", "your-operator-uuid")
req.Header.Set("X-Timestamp", timestamp)
req.Header.Set("X-HMAC-SHA256", signature)

import hmac, hashlib, json, time, requests

operator_id = "your-operator-uuid"
secret = "your-hmac-secret"
payload = {
    "playerId": "test-player",
    "currency": "USD",
    "gameCode": "dice-alpha",
    "countryCode": "US",
    "demo": True,
}
body = json.dumps(payload, separators=(",", ":"))
timestamp = str(int(time.time()))
path = "/operator/launch"

signature = hmac.new(
    secret.encode(), (timestamp + path + body).encode(), hashlib.sha256
).hexdigest()

resp = requests.post(
    "https://rgs-staging.jackpot.studio/operator/launch",
    json=json.loads(body),
    headers={
        "X-Operator-ID": operator_id,
        "X-Timestamp": timestamp,
        "X-HMAC-SHA256": signature,
    },
)

Open the launchUrl from the response in a browser to play the game with virtual funds.

Implement and Test Callbacks

Once you've seen how games work, implement the five wallet callback endpoints on your backend:

Endpoint	Purpose
`POST /callback/authenticate`	Verify player and return balance on session launch
`POST /callback/debit`	Deduct bet amount from player balance
`POST /callback/credit`	Credit winnings to player balance
`POST /callback/balance`	Return current player balance
`POST /callback/rollback`	Reverse a failed bet

See Wallet Callbacks for full request/response schemas and code examples.

After implementing, provide your callback base URL (if you haven't already) and run the Integration Tester to validate your implementation.

Open Integration Tester

All Happy Path tests should pass before moving to production. If you run into any issues, save the test report as a PDF and send it to us so we can help debug.

Go Live

Once your integration passes the tester:

We provision your production operator credentials
Launch with real players using "demo": false (or just omit the field)

Next Steps

Quick Start

Full technical walkthrough of the launch and game flow

Authentication

HMAC-SHA256 request signing details

Wallet Callbacks

Full callback request/response schemas

Introduction

Quick Start