Clone API

The Clone API is a separate product from our original API. It gives your players our native casino catalogue (slots, table and crash games). The protocol is deliberately identical to the original native-casino protocol: the same paths, fields, signature and wallet callback. If you already have an integration for that protocol, you only change the base URL and the credentials.

1. 1Open Dashboard → Clone API and activate it. You get a merchant_key (starts with CLN_) and an api_secret. The secret is shown in full only once; you can reveal or rotate it later on the same page.
2. 2Copy the base URL from the same page. In this document it is written as https://api.slotix.bet/clone, so a full URL looks like https://api.slotix.bet/clone/v1/native/games.
3. 3Set your clone wallet callback URL on the same page. Without it games cannot be launched (CLONE_CASINO_NOT_CONFIGURED).
4. 4Top up your clone balance in every currency you will use (see Billing).

Differences from the original protocol

Conventions

• Requests to us: JSON body (Content-Type: application/json) for POST/PATCH; query string for GET/DELETE. Form-urlencoded bodies are accepted too.
• Every endpoint except the demo launch is signed (see Authentication).
• Authentication errors look like { ok:false, error_code, error_description }. Endpoint errors look like { error, message } (some add extra fields such as enabled_currencies or valid_amounts). Validation errors of the request itself (BAD_REQUEST, bad image_style / updated_since, BAD_PRODUCT, BAD_DATE) use the { ok:false, error_code, error_description } form. Read error or error_code.
• player_id is your player id: 1–64 characters of A-Z a-z 0-9 _ . : @ -. The player is created on our side the first time you launch a game (or create a freespin / promo redemption / give-buy) for it.
• Currencies are ISO-3 codes. Nothing is ever converted between currencies. If you do not send currency, your account default currency is used.
• Rate limit: 1200 requests per minute per merchant_key by default (demo launch: 120 per minute per IP). Above it: 429 { success:false, error }. While our service is starting up you may briefly get 503: retry.

Every request carries four headers. The signature is HMAC-SHA1 over all request fields plus the three other headers. The same scheme is used in both directions: wallet callbacks we send you are signed with your api_secret and carry your merchant_key in X-Merchant-Id.

Building the hash string

1. 1Merge every query parameter, every body field and the three headers X-Merchant-Id, X-Timestamp, X-Nonce into one map.
2. 2Drop fields whose value is null (they are not signed, but you may still send them, e.g. rtp: null).
3. 3Sort the keys by byte order (so the X-… keys come before lower-case keys).
4. 4Join as key=encodeURIComponent(value) with &. Values are signed as the server parses them: the JSON number 150.00 is signed as 150, true as true.
5. 5X-Sign = lowercase hex of HMAC-SHA1(api_secret, hashString).

POST https://api.slotix.bet/clone/v1/native/vs20olympgate/launch
X-Merchant-Id: CLN_8F2A61C09D3B7E45
X-Timestamp: 1760180000
X-Nonce: 3f9c2b7d6a1e4c58b0d2f7a9e1c3b5d7
X-Sign: <see below>
Content-Type: application/json

{"player_id":"u1001","balance":150.00,"currency":"TRY"}

# 1) merge query + body + the 3 headers, drop null values
# 2) sort keys by byte order (upper-case "X-..." keys come first)
# 3) key=encodeURIComponent(value) joined by "&"   (150.00 is signed as 150)
X-Merchant-Id=CLN_8F2A61C09D3B7E45&X-Nonce=3f9c2b7d6a1e4c58b0d2f7a9e1c3b5d7&X-Timestamp=1760180000&balance=150&currency=TRY&player_id=u1001

# 4) X-Sign = lowercase hex of HMAC-SHA1(api_secret, hash string)

// Node.js 18+ (global fetch)
const crypto = require('crypto');

const BASE = 'https://api.slotix.bet/clone';          // copy yours from Dashboard -> Clone API
const MERCHANT_KEY = process.env.CLONE_MERCHANT_KEY; // CLN_...
const API_SECRET = process.env.CLONE_API_SECRET;

function hashString(fields) {
  return Object.keys(fields)
    .filter(k => fields[k] !== null && fields[k] !== undefined)   // nulls are not signed
    .sort()                                                        // byte order
    .map(k => k + '=' + encodeURIComponent(String(fields[k])))
    .join('&');
}

async function cloneApi(method, path, { query = {}, body = null } = {}) {
  const headers = {
    'X-Merchant-Id': MERCHANT_KEY,
    'X-Timestamp': String(Math.floor(Date.now() / 1000)),
    'X-Nonce': crypto.randomBytes(16).toString('hex'),          // single use
  };
  const fields = { ...query, ...(body || {}), ...headers };
  headers['X-Sign'] = crypto.createHmac('sha1', API_SECRET).update(hashString(fields)).digest('hex');

  const qs = new URLSearchParams(query).toString();
  const res = await fetch(BASE + path + (qs ? '?' + qs : ''), {
    method,
    headers: body ? { ...headers, 'Content-Type': 'application/json' } : headers,
    body: body ? JSON.stringify(body) : undefined,
  });
  return { status: res.status, data: await res.json() };
}

// examples (CommonJS has no top-level await, so they run inside an async function)
(async () => {
  const games = await cloneApi('GET', '/v1/native/games', { query: { page: 1, per_page: 200 } });
  const launch = await cloneApi('POST', '/v1/native/vs20olympgate/launch', {
    body: { player_id: 'u1001', balance: 150.0, currency: 'TRY', language: 'tr' },
  });
  console.log(games.status, launch.data);
})();

Authentication errors

HTTP/1.1 401 Unauthorized
{
  "ok": false,
  "error_code": "BAD_SIGNATURE",
  "error_description": "Signature does not match"
}

{
  "items": [
    {
      "uuid": "clone-vs20olympgate",
      "slug": "vs20olympgate",
      "name": "Gates of Olympus",
      "provider": "Pragmatic Play",
      "image": "https://cdn.example.com/games/vs20olympgate-portrait.webp",
      "image_portrait": "https://cdn.example.com/games/vs20olympgate-portrait.webp",
      "image_landscape": "https://cdn.example.com/games/vs20olympgate-landscape.webp",
      "type": "slots",
      "technology": "html5",
      "is_mobile": 1,
      "has_lobby": 0,
      "has_tables": 0,
      "has_freespins": 1,
      "freespin_valid_until_full_day": 0,
      "rtp": 96.5,
      "bet_options": [0.2, 0.4, 1, 2, 4, 10, 20, 40, 100],
      "is_native": true,
      "active": true,
      "updated_at": 1760170000
    }
  ],
  "_meta": { "totalCount": 1874, "pageCount": 10, "currentPage": 1, "perPage": 200 }
}

Games are ordered by name. If the platform limited your account to certain providers, only their games are listed.

{
  "items": [
    { "code": "pragmatic", "label": "Pragmatic Play", "games": 512 },
    { "code": "evolution", "label": "Evolution", "games": 230 }
  ]
}

Only providers with at least one active game are listed, ordered by game count.

{slug} is the game uuid without clone- (e.g. clone-vs20olympgate → /v1/native/vs20olympgate/launch). Open the returned url in an iframe or a new window.

POST /v1/native/vs20olympgate/launch
Content-Type: application/json

{
  "player_id": "u1001",              // your own player id
  "balance": 150.00,                 // player's current balance in that currency
  "currency": "TRY",
  "language": "tr",
  "return_url": "https://your-casino.example/lobby",
  "nickname": "lucky_ahmet"
}

HTTP/1.1 200 OK
{ "url": "https://play.example.com/game/....." }

// the game is under maintenance: the URL still works, show a notice if you like
{ "url": "https://play.example.com/game/.....", "_error": "GAME_UNDER_MAINTENANCE" }

HTTP/1.1 400 Bad Request
{ "error": "CURRENCY_NOT_ENABLED", "message": "EUR is not enabled on your account", "enabled_currencies": ["TRY", "USD"] }

HTTP/1.1 402 Payment Required
{ "error": "CLONE_CREDIT_EXHAUSTED", "message": "Your clone balance in TRY is empty" }

Demo launch needs no signature and touches no wallet. Parameters (query string or body):

# no signature needed - GET or POST
GET https://api.slotix.bet/clone/v1/native/vs20olympgate/launch-demo?balance=5000&currency=TRY&lang=tr

{ "url": "https://play.example.com/demo/....." }

Unknown slug → 404 { error: 'Game not found' }. Live casino games and some providers answer 400 DEMO_NOT_SUPPORTED. Limited to 120 requests per minute per IP.

Money never moves on our side: every stake and every payout is a request to your wallet. We call the single clone callback URL you set in Dashboard → Clone API.

• POST, Content-Type: application/x-www-form-urlencoded, every value is a string.
• Signed exactly like your requests to us, with your api_secret; X-Merchant-Id is your merchant_key. Verify the signature and accept a clock window of ±300 s.
• action is bet, win or rollback.
• Redirects are not followed. Enter the final URL (exact scheme, host and path): a 301/302 answer counts as unknown, so every bet fails and wins pile up for redelivery.
• Everything is idempotent by `transaction_id`: the same transaction can reach you more than once.

Fields we send

bet

Debit amount from the player and answer with the new balance, or reject it. A rejected bet is not played; the stake stays with the player in the game.

POST https://your-casino.example/clone/wallet
Content-Type: application/x-www-form-urlencoded
X-Merchant-Id: CLN_8F2A61C09D3B7E45          <- YOUR merchant_key
X-Timestamp: 1760180000
X-Nonce: 9a1d0c2e7b4f45a8b3e6d1f0c9a8b7e6
X-Sign: 5b2e...                              <- HMAC-SHA1 with YOUR api_secret

action=bet
transaction_id=tx_7c1f9e20a4
player_id=u1001
session_id=s_51a0e7
round_id=r_88213907
game_uuid=clone-vs20olympgate
currency=TRY
amount=2.5
type=bet
finished=false
transaction_datetime=2026-10-11T09:15:02.000Z
casino_request_retry_count=0

win

Credit amount (it can be 0 when a round is closed without a payout). Freespin wins carry the freespin fields:

action=win
transaction_id=tx_7c1f9e31b0
player_id=u1001
session_id=s_51a0e7
round_id=r_88213990
game_uuid=clone-vs20olympgate
currency=TRY
amount=48
type=win
finished=true
transaction_datetime=2026-10-11T09:21:40.000Z
casino_request_retry_count=0
freespin_id=WELCOME-50            <- YOUR freespin_id
quantity=50
freespin_settlement=total_at_end
freespin_total=48
freespin_partial=0

rollback (our addition)

We send rollback when a bet could not be confirmed towards the game and we cancel it. If you debited that bet, credit it back. If you never saw it, simply answer ok (and ideally remember it, so that a late copy of that bet is refused). A rollback is idempotent by its own transaction_id (rb_…) and must always be answered with { ok: true, balance }.

action=rollback
transaction_id=rb_tx_7c1f9e20a4      <- unique id of the rollback itself
bet_transaction_id=tx_7c1f9e20a4     <- the bet to cancel
player_id=u1001
session_id=s_51a0e7
round_id=r_88213907
game_uuid=clone-vs20olympgate
currency=TRY
amount=2.5                           <- the bet amount
type=rollback
finished=true
transaction_datetime=2026-10-11T09:15:02.000Z
casino_request_retry_count=0

Your answer and how we read it

// accepted (HTTP 2xx) - balance is the player's balance AFTER this operation, as a number
{ "ok": true, "balance": 147.5 }

// rejected (only meaningful for a bet)
{ "ok": false, "error_code": "INSUFFICIENT_FUNDS" }

Bet error codes

These codes are passed to the game as they are. Any other code becomes `BET_REJECTED`.

Timing and retries

• Answer within about 2 seconds. The game server gives up waiting at 2.8 s, and we need part of that time ourselves.
• If your bet answer does not arrive in time (or is unknown), the game retries and we call you again with the same `transaction_id` and a higher casino_request_retry_count. Return the result you already applied; never debit twice.
• If the round is finally abandoned (after a few minutes without a definitive answer), we send rollback for that bet.
• Wins and rollbacks that you do not confirm are redelivered by us: first after 30 s, then with doubling intervals up to every 30 minutes, until you answer ok: true.

Never reject a win

A complete wallet callback handler: signature check (±300 s), bet / win / rollback, idempotency by transaction_id, one database transaction per call with the player row locked. Adapt the SQL to your own schema.

-- PostgreSQL. Your players table probably exists already; it only needs a balance per currency.
CREATE TABLE players (
  player_id  text          NOT NULL,
  currency   char(3)       NOT NULL,
  balance    numeric(20,4) NOT NULL DEFAULT 0,
  blocked    boolean       NOT NULL DEFAULT false,
  PRIMARY KEY (player_id, currency)
);

-- one row per transaction_id: this IS your idempotency
CREATE TABLE clone_wallet_tx (
  transaction_id  text PRIMARY KEY,
  action          text          NOT NULL,   -- bet | win | rollback | cancelled
  player_id       text          NOT NULL,
  currency        char(3)       NOT NULL,
  amount          numeric(20,4) NOT NULL,
  ok              boolean       NOT NULL,
  error_code      text,
  rolled_back     boolean       NOT NULL DEFAULT false,
  created_at      timestamptz   NOT NULL DEFAULT now()
);

// Express + pg. POST https://your-casino.example/clone/wallet
const express = require('express');
const crypto = require('crypto');
const { Pool } = require('pg');

const MERCHANT_KEY = process.env.CLONE_MERCHANT_KEY; // CLN_...
const API_SECRET = process.env.CLONE_API_SECRET;
const db = new Pool();
const app = express();

function hashString(fields) {
  return Object.keys(fields)
    .filter(k => fields[k] !== null && fields[k] !== undefined)
    .sort()
    .map(k => k + '=' + encodeURIComponent(String(fields[k])))
    .join('&');
}

function safeEqual(a, b) {
  const x = Buffer.from(String(a)), y = Buffer.from(String(b));
  return x.length === y.length && x.length > 0 && crypto.timingSafeEqual(x, y);
}

app.post('/clone/wallet', express.urlencoded({ extended: false }), async (req, res) => {
  // 1) authenticate: same scheme as your requests to us, window +-300 s
  const h = {
    'X-Merchant-Id': req.get('X-Merchant-Id') || '',
    'X-Timestamp': req.get('X-Timestamp') || '',
    'X-Nonce': req.get('X-Nonce') || '',
  };
  const sign = String(req.get('X-Sign') || '').toLowerCase();
  if (!h['X-Merchant-Id'] || !h['X-Timestamp'] || !h['X-Nonce'] || !sign)
    return res.status(401).json({ ok: false, error_code: 'AUTH_REQUIRED' });
  if (h['X-Merchant-Id'] !== MERCHANT_KEY)
    return res.status(401).json({ ok: false, error_code: 'UNKNOWN_MERCHANT' });
  if (Math.abs(Date.now() / 1000 - Number(h['X-Timestamp'])) > 300)
    return res.status(401).json({ ok: false, error_code: 'TIMESTAMP_EXPIRED' });
  const fields = req.body || {};
  const expected = crypto.createHmac('sha1', API_SECRET).update(hashString({ ...fields, ...h })).digest('hex');
  if (!safeEqual(expected, sign))
    return res.status(401).json({ ok: false, error_code: 'BAD_SIGNATURE' });

  if (!['bet', 'win', 'rollback'].includes(fields.action))
    return res.status(400).json({ ok: false, error_code: 'UNKNOWN_ACTION' });

  // 2) apply - one DB transaction, player row locked
  try {
    res.json(await apply(fields));
  } catch (err) {
    console.error('clone wallet error', err);
    res.status(500).json({ ok: false, error_code: 'INTERNAL_ERROR' }); // 5xx = "unknown": we will ask again
  }
});

async function apply(f) {
  const c = await db.connect();
  try {
    await c.query('BEGIN');
    const answer = await decide(c, f);
    await c.query('COMMIT');
    return answer;
  } catch (e) {
    await c.query('ROLLBACK').catch(() => {});
    throw e;
  } finally {
    c.release();
  }
}

async function decide(c, f) {
  // lock the player's balance: serialises every money movement of this player
  const p = (await c.query(
    'SELECT balance, blocked FROM players WHERE player_id = $1 AND currency = $2 FOR UPDATE',
    [f.player_id, f.currency])).rows[0];
  if (!p && f.action === 'bet') return { ok: false, error_code: 'PLAYER_NOT_FOUND' };
  // never refuse a win or rollback (it would be redelivered forever): open the wallet at 0
  if (!p) await c.query('INSERT INTO players (player_id, currency) VALUES ($1, $2) ON CONFLICT DO NOTHING', [f.player_id, f.currency]);
  let balance = p ? Number(p.balance) : 0;

  // idempotency: the same transaction_id always gets the same outcome
  const seen = (await c.query('SELECT ok, error_code FROM clone_wallet_tx WHERE transaction_id = $1', [f.transaction_id])).rows[0];
  if (seen) return seen.ok ? { ok: true, balance } : { ok: false, error_code: seen.error_code };

  const record = (id, action, amount, ok, code = null) => c.query(
    'INSERT INTO clone_wallet_tx (transaction_id, action, player_id, currency, amount, ok, error_code) VALUES ($1,$2,$3,$4,$5,$6,$7)',
    [id, action, f.player_id, f.currency, amount, ok, code]);
  const move = async (sql, amount) => {
    const r = await c.query(sql, [amount, f.player_id, f.currency]);
    if (r.rowCount) balance = Number(r.rows[0].balance);
    return r.rowCount > 0;
  };

  if (f.action === 'bet') {
    if (p.blocked) {
      await record(f.transaction_id, 'bet', f.amount, false, 'PLAYER_BLOCKED');
      return { ok: false, error_code: 'PLAYER_BLOCKED' };
    }
    const debited = await move(
      'UPDATE players SET balance = balance - $1::numeric WHERE player_id = $2 AND currency = $3 AND balance >= $1::numeric RETURNING balance',
      f.amount);
    if (!debited) {
      await record(f.transaction_id, 'bet', f.amount, false, 'INSUFFICIENT_FUNDS');
      return { ok: false, error_code: 'INSUFFICIENT_FUNDS' };
    }
    await record(f.transaction_id, 'bet', f.amount, true);
    return { ok: true, balance };
  }

  if (f.action === 'win') {
    // never refuse a win: if you answer an error we simply deliver it again later
    await move('UPDATE players SET balance = balance + $1::numeric WHERE player_id = $2 AND currency = $3 RETURNING balance', f.amount);
    await record(f.transaction_id, 'win', f.amount, true);
    return { ok: true, balance };
  }

  // rollback: cancel bet_transaction_id
  const bet = (await c.query(
    'SELECT action, ok, amount, rolled_back FROM clone_wallet_tx WHERE transaction_id = $1 FOR UPDATE',
    [f.bet_transaction_id])).rows[0];
  if (!bet) {
    // you never saw that bet: remember it as cancelled so a late copy of it is refused
    await record(f.bet_transaction_id, 'cancelled', f.amount, false, 'BET_REJECTED');
  } else if (bet.action === 'bet' && bet.ok && !bet.rolled_back) {
    // you debited it: give back exactly what you took
    await move('UPDATE players SET balance = balance + $1::numeric WHERE player_id = $2 AND currency = $3 RETURNING balance', bet.amount);
    await c.query("UPDATE clone_wallet_tx SET rolled_back = true, ok = false, error_code = 'BET_REJECTED' WHERE transaction_id = $1", [f.bet_transaction_id]);
  }
  await record(f.transaction_id, 'rollback', f.amount, true);
  return { ok: true, balance };                   // always ok for a rollback
}

app.listen(8080);

POST /v1/dashboard/native-freespins
{
  "player_id": "u1001",
  "game_uuid": "clone-vs20olympgate",
  "quantity": 50,
  "bet_per_spin": 20,
  "valid_until_days": 7,
  "currency": "TRY",
  "freespin_id": "WELCOME-50"
}

HTTP/1.1 201 Created
{
  "data": {
    "id": 81234,
    "freespin_id": "WELCOME-50",
    "player_id": "u1001",
    "game_uuid": "clone-vs20olympgate",
    "quantity": 50,
    "status": "ACTIVE",
    "valid_until": "2026-10-18T23:59:59Z"
  }
}

GET    /v1/dashboard/native-freespins?status=ACTIVE
DELETE /v1/dashboard/native-freespins/WELCOME-50

{ "data": { "freespin_id": "WELCOME-50", "cancelled": true } }

Wins arrive as normal win callbacks with freespin_id. With freespin_settlement = per_spin every spin is paid as its own win; with total_at_end you get one win with the campaign total (freespin_total) when the campaign ends. If the player stops playing for 30 minutes, the amount won so far is paid out as a partial win with freespin_partial = 1. Partial payouts are not cumulative: the campaign result is the sum of all wins with freespin_total = 1 for that freespin_id. A retried win can arrive after the campaign has ended — credit it by transaction_id. type = freespin without freespin_id is free spins won inside a normal paid round: credit it like any win.

A promo code gives free spins on one game to every player who redeems it.

POST /v1/dashboard/native-promo-codes
{
  "code": "AUTUMN50",
  "name": "Autumn campaign",
  "game_slug": "vs20olympgate",
  "freespin_count": 50,
  "bet_per_spin": 20,
  "freebet_expires_days": 7,
  "max_uses": 1000,
  "max_uses_per_user": 1,
  "expires_at": "2026-11-30T23:59:59Z"
}

GET    /v1/dashboard/native-promo-codes
PATCH  /v1/dashboard/native-promo-codes/AUTUMN50      { "is_active": 0 }
DELETE /v1/dashboard/native-promo-codes/AUTUMN50

POST /v1/dashboard/native-promo-codes/redeem
{ "player_id": "u1001", "code": "AUTUMN50", "currency": "TRY" }

HTTP/1.1 201 Created
{
  "data": {
    "player_id": "u1001",
    "game_slug": "vs20olympgate",
    "freespin_id": "...",
    "freespin_count": 50,
    "valid_until": "2026-10-18T23:59:59Z"
  }
}

Lists the features (gifted calls, free spins, bonus buys …) currently active for your players only, with your player_id.

GET /v1/native/active-features

{
  "items": [
    { "player_id": "u1001", "...": "feature fields" }
  ],
  "count": 1
}

POST /v1/native/give-call    { "player_id": "u1001", "mult": 50, "winTotal": 100 }
POST /v1/native/give-fs      { "player_id": "u1001", "mult": 10 }
POST /v1/native/give-promo   { "player_id": "u1001", "prizeId": 3 }
POST /v1/native/give-promo   { "player_id": "u1001", "jpFamily": "...", "jpLevel": 2 }

POST   /v1/native/give-buy   { "player_id": "u1001", "game": "clone-vs20olympgate", "amount": 100,
                               "option": 1, "currency": "TRY", "expires_in_hours": 24 }
GET    /v1/native/give-buy?player_id=u1001
DELETE /v1/native/give-buy/{call_id}

HTTP/1.1 400 Bad Request
{ "error": "INVALID_AMOUNT", "valid_amounts": [20, 40, 100, 200] }

GET /v1/native/give-call/options?game=vs20gtsofhades&player_id=u1001
-> { "supported": true, "current_bet": 2, "items": [ { "mult": 0.45, "winTotal": 9 }, ... ] }
GET /v1/native/give-fs/options?game=vs20gtsofhades
-> { "supported": true, "random_allowed": true, "items": [ { "mult": 2.4, "winTotal": 48 }, ... ] }
GET /v1/native/give-promo/options?game=vs20gtsofhades
-> { "promo_type": "wheel_piece", "wheel": { "prizes": [ { "prizeId": 3, "type": "bet_multiplier", ... } ] } }

• give-call, give-fs and give-promo apply to the player's most recent game session and are paid on the next spin there. If the player has moved to another game, open the target game first, then send the gift.
• A gift never starts inside a feature: during free spins or a bonus it waits for the next normal spin. Gifts sent while another one is waiting are queued (up to 20) and applied in order; reopening the same game moves them to the new session.
• mult is relative to the player's bet (paid win = mult × current bet). A mult that is not in the options list is accepted, but the closest real result is used — send list values when the amount must match exactly. supported: false = do not offer that gift for the game.
• give-buy: Pragmatic Play games with a bonus buy only. It stays pending until the player opens that game in the same currency before expires_in_hours (default 24, max 168); then a normal bet with operator_buy_id arrives and counts in GGR. If your wallet rejects that bet, the status becomes failed.
• auto-call: when the player's RTP falls below low, it is raised to boost until it is back above high; cap is the maximum given per day (default 5000).

Bonus-call

Lets the player win approximately amount (target net win, in currency) over their next spins. Works on slot providers with RTP control; live games are excluded. The player keeps playing their own spins; a call waits while the player is offline and finishes when the target is reached, when cancelled, after 6 hours idle or when the promo balance is used up.

POST /v1/native/bonus-call                  { "player_id": "u1001", "amount": 500, "currency": "TRY" }
POST /v1/native/bonus-call/cancel           { "player_id": "u1001" }

# same, dashboard-style paths
POST /v1/dashboard/casino/bonus-call        { "player_id": "u1001", "amount": 500, "currency": "TRY" }
POST /v1/dashboard/casino/bonus-call/cancel { "player_id": "u1001" }
GET  /v1/dashboard/casino/bonus-call        -> { "data": [ { "player_id": "u1001", "call_status": 1, ... } ] }

Gifts and bonus-call amounts are promo money and are billed at the promo rate, see Billing.

PATCH /v1/native/auto-call
{ "player_id": "u1001", "enabled": true, "low": 60, "high": 120, "boost": 110, "cap": 1000 }

You manage the RTP and the bet limits of your own players. Settings are stored per merchant. A changed RTP rule is sent at once to your players active in the last 24 hours and to everyone else at their next launch; a per-player RTP is sent at once. If an RTP cannot be applied, the launch is refused with 503 RTP_NOT_APPLIED — a game never opens at a wrong RTP. Other merchants are never affected. The game server reads the RTP on every spin, so a change reaches a game that is already open from its next spin. Live casino tables do not use RTP settings (only bet limits apply there).

RTP

PATCH /v1/native/rtp   { "all": true, "rtp": 96 }                 # all your games
PATCH /v1/native/rtp   { "provider": "Pragmatic", "rtp": 94 }      # one provider (code from /providers)
PATCH /v1/native/rtp   { "slug": "vs20olympgate", "rtp": 92 }      # one game
PATCH /v1/native/rtp   { "provider": "Pragmatic", "rtp": null }    # remove a rule
GET   /v1/native/rtp   -> { "items": [ { "scope": "provider", "target": "Pragmatic", "rtp": 94 }, ... ] }

PATCH /v1/native/player-rtp
{ "player_id": "u1001", "rtp": 92 }

# remove the override (null is not part of the signature)
{ "player_id": "u1001", "rtp": null }

• Precedence: player RTP → game rule → provider rule → merchant-wide rule → platform default.
• A player with two games open at the same time plays both at the RTP of the game launched last.
• GET /v1/native/rtp lists your rules. The panel’s RTP & bet limits page does the same with a form.

Bet limits

PATCH /v1/native/bet-limits { "all": true, "min": 1, "max": 500 }
PATCH /v1/native/bet-limits { "provider": "Pragmatic", "min": 0.2, "max": 100, "currency": "TRY" }
PATCH /v1/native/bet-limits { "provider": "Pragmatic", "min": null, "max": null }   # remove
GET   /v1/native/bet-limits -> { "items": [ { "provider": "Pragmatic", "currency": "TRY", "min": 0.2, "max": 100 }, ... ] }

# per player session, in the launch body (overrides the stored limits field by field)
POST /v1/native/vs20olympgate/launch { "player_id": "u1001", "balance": 150, "currency": "TRY", "min_bet": 0.5, "max_bet": 50 }

• Precedence: provider + currency → provider → all + currency → all. min_bet / max_bet sent in a launch override them field by field.
• Limits restrict the bets the player can choose; they do not change the RTP. Live-casino type limits are not available (400 BAD_TYPE).
• PATCH /v1/native/bet-scale is managed by the platform: 403 NOT_AVAILABLE.

Replays of your own rounds and sessions. Anything that does not belong to your players returns 404.

GET /v1/replay/spin/r_88213907
GET /v1/replay/session/s_51a0e7
GET /v1/replay/launch/s_51a0e7
GET /v1/replay/campaign/WELCOME-50

HTTP/1.1 410 Gone
{ "error": "no_replay_video", "roundDetailUrl": "https://..." }

GET /v1/merchant/wallet

{
  "ok": true,
  "merchant_id": "CLN_8F2A61C09D3B7E45",
  "originals": [],
  "clone": [
    { "currency": "TRY", "balance": 12450.75 },
    { "currency": "USD", "balance": 830 }
  ],
  "sportsbook": [],
  "totals_by_currency": { "TRY": 12450.75, "USD": 830 },
  "generated_at": "2026-10-11T09:30:00.000Z"
}

originals and sportsbook are always empty arrays here; the Clone API only has the clone balances.

GET /v1/merchant/reconciliation?product=native&date=2026-10-10&page=1&per_page=1000

{
  "ok": true,
  "product": "native",
  "date": "2026-10-10",
  "timezone": "UTC",
  "summary": [
    { "currency": "TRY", "bets": { "count": 18233, "amount": 92311.5 },
      "wins": { "count": 6102, "amount": 88120.25 }, "net": 4191.25 }
  ],
  "transactions": [
    { "transaction_id": "tx_7c1f9e20a4", "action": "bet", "amount": 2.5, "currency": "TRY",
      "player_id": "u1001", "round_id": "r_88213907", "game_uuid": "clone-vs20olympgate",
      "operator_give": false, "created_at": "2026-10-10T09:15:02.114Z" }
  ],
  "_meta": { "totalCount": 24335, "pageCount": 25, "currentPage": 1, "perPage": 1000 }
}

Lists your transactions as we recorded them, completed only (refused or rolled-back bets are not included). A win is listed as soon as the game reports it, even if its delivery to your wallet is still being retried, so a win missing on your side for a few minutes is normal; it arrives with the same transaction_id. operator_give: true marks promo-funded money when the game flags it live; gifts identified later are only billed (see Billing). Compare it daily with your own clone_wallet_tx table; there are no sub-agent endpoints.

The Clone API is prepaid, per currency. You hold a clone credit balance in each currency you use (see it in Dashboard → Clone API or /v1/merchant/wallet). Currencies are never converted: TRY play is charged from your TRY balance.

• Your GGR rate is applied when you pay. Every payment is loaded as payment ÷ GGR rate of credit: at 10 %, 100 TRY paid gives 1000 TRY credit; at 5 %, 2000. The rate (shown in Dashboard → Clone API) is fixed for that payment.
• Provider pool. For every provider and currency you have a pool. Wins of that provider in that currency refill the pool.
• GGR is deducted 1:1. Each bet first uses the pool. The part of the bet not covered by the pool is deducted from your credit 1:1.
• Refused bets. If your clone balance cannot cover the GGR of a bet, the bet is refused towards the game with MERCHANT_CREDIT_EXHAUSTED (you receive no callback). New launches in that currency get 402 CLONE_CREDIT_EXHAUSTED once your balance (plus any credit limit the platform granted you) is used up.
• Rejected or rolled-back bets are fully reversed: the pool and the charge are given back.
• Promo money. Operator gifts and bonus-call amounts are a real cost: they cost the promo rate (default 100 %) of their amount, converted into credit at your GGR rate (at 10 %: a 10 TRY gift = 100 credit), and do not refill the pool. A bonus-call is charged on the amount actually given when it ends, not on the requested amount.
• Gift wins are settled the next day. Gifts the game does not flag live are identified in the daily reconciliation (after 04:00 UTC for the previous day): they are then taken out of the pool and charged at the promo rate. Promo charges may take your clone balance below zero.

GGR rate 10 %, currency TRY
payment 100 TRY  -> credit loaded 100 / 10 % = 1000 TRY

provider X, pool starts at 0
bet  100  -> pool covers 0,   uncovered 100 -> credit -100   pool 0
win  150  ->                                  credit    0    pool 150
bet  100  -> pool covers 100, uncovered 0   -> credit    0   pool 50
bet   80  -> pool covers 50,  uncovered 30  -> credit  -30   pool 0
                                              ------------
                          credit used: 130   (= 13 TRY of your payment)
                          credit left: 870

operator gift 10 TRY (promo 100 %) -> credit -100 (10 / 10 %)

Codes our API returns to you

Codes your wallet may return for a bet

INSUFFICIENT_FUNDS, PLAYER_BLOCKED, PLAYER_NOT_FOUND, CURRENCY_NOT_SUPPORTED, INVALID_TOKEN, BET_LIMIT_EXCEEDED are passed to the game; everything else becomes BET_REJECTED.

Codes the game may show for a bet that never reached you

1. 1Activate the Clone API in Dashboard → Clone API, store merchant_key and api_secret securely (server side only).
2. 2Copy the base URL; never hard-code the placeholder https://api.slotix.bet/clone.
3. 3Sign requests exactly as described; test GET /v1/native/providers first. Keep your server clock in sync (±60 s).
4. 4Sync the catalogue with GET /v1/native/games (per_page=200), then incrementally with updated_since + include_inactive=1.
5. 5Set your clone wallet callback URL. Verify our signature (±300 s) on every callback.
6. 6Implement bet, win and rollback, idempotent by transaction_id, answer { ok: true, balance } in under ~2 s.
7. 7Never reject a win; expect late and repeated wins.
8. 8Top up your clone balance in each currency you enable.
9. 9Launch with the slug (uuid without clone-) and the player’s current balance.
10. 10Reconcile daily with GET /v1/merchant/reconciliation.