Eight mechanics, one config model
Match-N, match-to-winner, reveal-value, and key-symbol scratch cards, wheel, beat-target dice, plinko, and pick-until-collect — all defined by the same prize pool + card schema.
Instant Win Game API
Cymba resolves instant-win rounds — scratch cards, wheels, dice, plinko, and pick games — from a JSON config. One call returns the drawn prize, the full card the player reveals, and provably fair verification material. You build the front-end; Cymba does the math.
API example
POST /api/v1/play
Authorization: Bearer cy_live_...
{
"config": "my-dice-game",
"client_seed": "player-chosen"
}
{
"result": {
"round_id": "9f2c41...",
"prize": { "prize_id": "m15", "multiplier": 15, "kind": "win" },
"card": {
"mechanic": "beat_target",
"cells": ["5", "2"],
"meta": { "your_value": 5, "target_value": 2 }
},
"result": { "total_multiplier": 15, "breakdown": { "base": 15 } }
},
"provably_fair": {
"server_seed_hash": "3e1c7d...",
"client_seed": "player-chosen",
"nonce": 42
}
}
An instant win game API resolves the outcome of a single-round game — a scratch card, a prize wheel, a dice duel, a plinko drop — the moment the player commits. There are no reels to evaluate and no paylines: the round has a prize table, the engine draws from it, and the player's reveal is presentation over a result that already exists.
Cymba exposes this as /api/v1/play — the same endpoint the slots engine uses; the config picks the engine. You define the game as a JSON config — a weighted prize pool plus a card section that names the mechanic — and each call returns the drawn prize, the exact card the player will reveal, the total multiplier, and provably fair verification material.
Most homegrown instant games get this backwards: they randomize the presentation and then work out what it pays. Cymba's engine draws the prize first, from the weighted pool, using the same HMAC-SHA256 RNG as the slots engine. Only then does it build a card that displays exactly that prize — and it validates the card's read-back against the drawn prize before returning. A round that reads as a 15× win is a 15× win; the API refuses to construct anything else.
That ordering is what makes the math auditable: RTP is a property of the prize pool alone: the PAR-sheet export computes it directly from the config, and /api/v1/rtp/{config_id} reports the observed return over logged rounds converging on it.
Every instant game shares the same skeleton:
prize_pool.entries — the outcome table: prize id, multiplier, weight.card.mechanic — one of match_n, match_to_winner, reveal_value, key_symbol, wheel, beat_target, plinko, pick_until_collect.card.mechanic_config — how that mechanic dresses the prize: symbols, board layout, margins, decoys.Switching a game from a scratch card to a wheel is a config edit, not an engine change. The dashboard's Instant-Win Studio builds these configs visually, with live RTP as you edit.
Cymba does not handle wallets, balances, player accounts, currency, licensing, or jurisdictional compliance. It returns multipliers; operators handle money.
Start with a free API key, clone a template, and run your first provably fair spin.