Beta testing Free API keys are open for testing. Paid tiers are waitlisted while we harden billing, legal, and audit workflows.

Scratch Card API

Digital scratch cards from a JSON prize table

Define the prize pool and pick a scratch mechanic — Cymba resolves each card server-side, returns the full grid the player scratches, and guarantees the card displays exactly the prize that was drawn. Provably fair, RTP-tracked, PAR-sheet exportable.

Four scratch mechanics

Match-N symbols to win, match your numbers to winning numbers, reveal a single value, or find the key symbol — each one a config choice, not custom code.

The card can't lie

The prize is drawn first; the grid is generated to display it and validated by read-back before the API responds. Decoy symbols never form an accidental win.

Weighted pools, engine-ready packs

Every card is a weighted draw from your prize pool. The engine also models finite pull-tab style packs — API support for pack state is on the roadmap.

API example

Resolve a match-to-winner scratch card

Request
POST /api/v1/play
Authorization: Bearer cy_live_...

{
  "config": "instant-lucky-numbers",
  "client_seed": "session-7f3a"
}
Response
{
  "result": {
    "round_id": "b81d2e...",
    "prize": { "prize_id": "p2", "multiplier": 10, "kind": "win" },
    "card": {
      "mechanic": "match_to_winner",
      "meta": {
        "winning_numbers": ["4", "19", "33"],
        "player_entries": [
          { "number": "19", "prize_id": "p2" },
          { "number": "7", "prize_id": "lose" },
          { "number": "36", "prize_id": "lose" }
        ]
      }
    },
    "result": { "total_multiplier": 10, "breakdown": { "base": 10 } }
  },
  "provably_fair": {
    "server_seed_hash": "3e1c7d...",
    "client_seed": "session-7f3a",
    "nonce": 43
  }
}

Scratch card math is a prize table, not a grid

A scratch card's grid is theater. The real game is the prize table behind it: which multipliers exist, at what weights, and what the pool pays back overall. Cymba makes that explicit — you define prize_pool.entries as {id, multiplier, weight} rows, and the scratch presentation is a separate, swappable layer.

That separation is what lets you tune a game's RTP without touching its look, or reskin a card without re-auditing its math.

Four ways to scratch

  • match_n — reveal N matching symbols to win that symbol's prize. Decoy layouts are generated so near-misses never pay.
  • match_to_winner — classic lottery style: your numbers vs. winning numbers; a hit pays the matched prize.
  • reveal_value — one panel, one value: the drawn prize shown directly.
  • key_symbol — find the key symbol anywhere on the card to unlock the prize.

Each is a card.mechanic value plus a small mechanic_config. The prize pool — and therefore the RTP — is untouched when you switch.

Built for operators who get audited

Every scratch config exports a PAR sheet: canonical config, theoretical RTP, and deterministic replay fixtures a third-party auditor can run offline. Every live card logs its seed material; /api/v1/verify reproduces the entire grid from revealed seeds, and /api/v1/verify-card audits any displayed card without them. You never have to ask a regulator — or a player — to trust the server.

What Cymba does not do

Cymba does not handle wallets, balances, ticket pricing, player accounts, or licensing. It returns multipliers; your platform handles money and jurisdiction.

Frequently Asked Questions

How does a digital scratch card work in Cymba?

Each card is one API call. The engine draws a prize from your weighted pool, builds a grid that displays that prize using the mechanic you configured, and returns both. The front-end animates the scratch; the outcome is already fixed and verifiable.

What stops a card from showing a win it doesn't pay?

The engine validates every generated card by reading it back through the mechanic's own win rule. If the display doesn't name exactly the drawn prize — including accidental matches formed by decoy symbols — the card is rejected and rebuilt. This check is part of the engine's test oracle, not an afterthought.

Can players verify a scratch card was fair?

Yes, two ways. After seed rotation, /api/v1/verify replays the full round — grid and all — from the revealed seeds, proving the card they scratched is the card the seeds produce. And /api/v1/verify-card audits any displayed card without seeds, reporting exactly the prize it shows.

How is RTP controlled?

RTP is the weighted average of the prize pool, independent of presentation. The PAR-sheet export computes it from the config, and the /rtp endpoint tracks observed RTP from logged plays.

Ready to test Cymba?

Start with a free API key, clone a template, and run your first provably fair spin.