Ship slot and instant-win games without building the math engine. POST a JSON config — get back provably fair, replayable multipliers in under 40 ms.
// curl curl -X POST /api/v1/play \ -H "Authorization: Bearer cy_live_***" \ -d '{ "config": "luna-rush-v2", "lines": 20, "client_seed": "b7c2…" }'
// → application/json { "result": { "reel_positions": […], "wins": […], "total_multiplier": —, "round_id": "…" }, "provably_fair": { "server_seed_hash": "…", "client_seed": "b7c2…", "nonce": — } }
Stop reinventing game math. Focus on the player experience — Cymba handles the engine.
Every spin uses HMAC-SHA256 of (server_seed, client_seed, nonce) — 52 bits of mantissa per draw. Commit hashes published before the bet; verify anywhere.
Six evaluation modes built in — consecutive paylines, full-line, ways-to-win (243 → 117,649 megaways-style), count-pay, cluster pays with BFS adjacency, and symbol groups. Switch in the config, not the code.
Cascading reels with multiplier progression, free spins with retriggers, hold & respin, mystery symbols, gamble, jackpots, meters, random multipliers, linked reels, symbol groups — plus the full wild family: expanding, sticky, stacked, walking, bomb, split, multiplier. And eight instant-win mechanics: scratch cards, wheel, dice, plinko, and pick games.
Exact combinatorial RTP where the math admits it, Monte Carlo at 200k samples otherwise. Volatility, scatter distribution, free-spin contribution — all returned in one shape.
Reels, symbols, payouts, scatter rules, cascade settings, wild traits — one object. Pin it on the dashboard, version it, or pass inline per request. Diffable and hash-stamped.
Manage API keys, configs, and round analytics from a single dashboard. Track total rounds, multipliers, observed RTP, and top-performing configs at a glance.
Every config exports a self-contained PAR sheet your math consultant can verify offline: canonical config, theoretical RTP, math reference inline, and five deterministic replay fixtures. Every live spin is replayable from (server_seed, client_seed, nonce). Give auditors everything they need without giving them access to our engine.
Click a mode below. Same 5×3 reel positions; the engine resolves them differently. Config snippet beneath each tab is exactly what flips the path — no code change.
Instant games resolve prize-first: the weighted pool draws the outcome, then the card is built to display exactly that prize — validated by read-back before the API responds. Switching mechanics is one config field; the math never moves.
Reveal N matching symbols to win that symbol's prize. Decoy layouts never form an accidental win.
"mechanic": "match_n"
Your numbers vs. winning numbers — classic lottery scratch, hit pays the matched prize.
"mechanic": "match_to_winner"
One panel, one value: the drawn prize shown directly. The simplest possible card.
"mechanic": "reveal_value"
Find the key symbol anywhere on the card to unlock the prize behind it.
"mechanic": "key_symbol"
A weighted prize wheel — segments are presentation, the pool decides the stop.
"mechanic": "wheel"
Dice duel: roll higher (or lower) than the house target by the configured margin.
"mechanic": "beat_target"
Board drop with prize buckets. The path is animation; the landing is the verified fact.
"mechanic": "plinko"
Open boxes until the stop symbol — collected prizes pay out, provably predetermined.
"mechanic": "pick_until_collect"
Same provably fair protocol as the slots engine — one seed commitment covers every /play round, slots and instant alike, and every card replays byte-identically from its seeds. Read the instant API docs →
Commit the seed before the bet. Reveal it at rotation. Anyone — your player, your auditor, an independent testing lab — can replay any spin and reach the same outcome, byte for byte. Try it below: mutate one character and watch integrity break.
Before any bet, Cymba publishes SHA-256 of a fresh server seed. The seed itself stays sealed until rotation.
Player supplies a client seed; nonce increments per spin within the session.
HMAC-SHA256(seed, client:nonce) maps to reel positions, scatter triggers, cascade orders. 52 bits per draw.
At rotation, the original server seed is published. Anyone can rehash and verify every spin under it.
A real replay fixture from basic-payline. Mutate any character — watch the integrity guarantee bite.
Go from zero to provably fair results in under five minutes. No SDK to install.
Reels, symbols, paylines, wilds, bonus mechanics — or an instant-win prize table — as one JSON config. Store it on the dashboard or pass it inline.
{
"name": "luna-rush-v2",
"reels": [5, 3],
"eval": "ways",
"ways": 243,
"wilds": ["expanding"],
"free_spins": { "retrigger": true }
}
Sign up, pick a plan, and mint a cy_live_ key. Free during the open beta — no card required.
cy_live_9f4a2c8e1b6d7039 cy_test_11ee44aa00bb2233 → scoped to your org → rotate via dashboard
Send your config ID and number of lines. Get back reel positions, win multipliers, and provably-fair seeds in one shot. Slots and instant games share the endpoint — the config picks the engine.
POST /api/v1/play { "config": "luna-rush-v2", "lines": 20 } 200 OK
Start free, scale when you're ready. Free tier is open during the beta — paid tiers join a waitlist while billing and audit workflows harden.
$0/mo
$19/mo
$149/mo
Custom
It resolves rounds — given a game config and a bet, it determines the outcome (reel positions for slots, card reveals for instant-win games, wins, bonuses) using the defined math model. You build the visuals; Cymba does the math.
No. Cymba provides the math engine as an API. You build the front-end, run your own platform, and handle your own licensing.
Slots: payline games (consecutive, full-line, or both), ways-to-win (243, 1024, up to 117,649 including megaways-style dynamic reels), count-pay, and cluster pays — with cascading reels, free spins with retriggers, hold & respin, mystery symbols, gamble, jackpots, linked reels, meters, and a full wild family (expanding, sticky, stacked, walking, bomb, split, multiplier). Instant win: eight outcome-determined mechanics — match-N, match-to-winner, reveal-value, and key-symbol scratch cards, wheel, beat-target dice, plinko, and pick-until-collect.
Each spin combines a server seed, client seed, and nonce via HMAC-SHA256 to generate deterministic outcomes. The server seed hash is committed before the spin — you or your players can verify the result was not tampered with. At seed rotation, the original server seed is revealed so anyone can replay every spin under it.
Yes. Define your own reel strips, symbol frequencies, paylines, payout tables, and feature rules — all via a JSON config. Store it in the dashboard or pass it inline with each request. Configs are versioned and exportable as PAR sheets.
The engine supports exact combinatorial analysis for standard payline and ways games, and Monte Carlo simulation (200k samples) for games with cascading, cluster, or hold & respin mechanics. Observed RTP is tracked per config via the /rtp endpoint.
Free during the open beta. No card required. PAR sheet exports the moment your first config is saved.