Prove which plays are real before a royalty dollar moves.

Follow one famous track through one royalty period.

The simplest way to understand SRPR: take a work everyone knows, run it through a single payout cycle on any platform, and watch where the signed receipt drops in. The platform keeps its own engine and its own data — SRPR seals the result. Same flow runs across every work in the catalog, every month — a song, a podcast, a film, an audiobook.

Pick one and watch the mechanism catch a fake play below.

Someone tries to game a payout. The determination fires. A receipt seals what really happened.

A fake stream is the same move everywhere: a bot or a bootleg pushes plays to skim a pool that belongs to real creators. Watch one fake attempt get caught, excluded, and sealed into a signed receipt the platform can hand a rightsholder, an auditor, or a court. The works cycle — a song, a podcast, a film, an audiobook — because the mechanism is identical.

The same receipt that proves an AI inference, pointed at a money-moving decision.

A fraud or AI-origin call is itself a model inference: a model takes an input and emits a determination. SRPR signs that determination the way we sign any inference — a commitment over the inputs, the model and policy version bound in, one post-quantum seal, verifiable offline by anyone. It is not a new kind of thing. It is the provenance rail for every model-made decision that moves a royalty dollar — built before a platform is forced to need it.

Streaming royalties are a fixed pro-rata pool. Every fake play steals from a real artist.

A platform pays ~70% of revenue into one pool, then splits it by share of real plays. Fraud, bots, and undisclosed AI tracks dilute the divisor — so honest creators get less than they earned. Platforms catch enormous volumes of this every year. What's missing is a way to prove, after the fact, which determination moved which dollar.

Set the pool. Set the fraud rate. See the dollars SRPR puts back.

This is the part that pays for itself. Move the sliders and watch how much of a royalty pool is being diluted by fraud and undisclosed AI — and how much a provable recovery rate returns to honest rightsholders, on a defensible, signed basis.

Priced as a primitive, not a tax. We charge for the proof and the protection.

We do not price per stream and we do not take a cut of the pool — the payout is not ours to claim. The model is three stacked lines, aligned so we get paid more only when more is protected. Figures below are illustrative and driven by adoption and provable recovery; the shape is the point.

Not just music. Any medium where a determination decides who gets paid.

Music is the clearest example, but the pattern is everywhere: a platform runs an engine that decides what counts — real vs. fake, human vs. AI, valid vs. invalid — and then money flows by share of what counted. Every one of those decisions is a model-made determination that moves a dollar. SRPR signs it. The determination engine differs by medium; the receipt is identical and portable across all of them.

One receipt. Every payer who runs a pro-rata pool.

Below is the music case in detail, since it is the largest and most contested today. The same primitive drops into any platform that pays creators by share of plays, views, or listens — the determination engine differs, the signed receipt is identical and portable.

Mint and verify an SRPR in your browser. No server. No secret.

This runs the actual SRPR primitive in your browser with WebCrypto. It commits each event, builds a Merkle root over the determinations, signs the payload, and verifies it offline. Then tamper with one outcome and watch verify reject it — exactly what an auditor's laptop would do.

// Click "Mint + sign receipt" to build a live SRPR.
// Everything below runs locally with WebCrypto — nothing leaves your browser.

A receipt only has value when an independent party issues it.

Your fraud teams are already world-class at catching bad streams. SRPR adds the one thing internal tooling structurally can't: proof a rightsholder, regulator, or artist can verify without taking anyone's word for it. We hand you that proof — you keep running your engine.

From this page to a live receipt to production, without a meeting.

You already minted a receipt above. The production path is the same three calls, pointed at your determination engine. Drop-in SDK, one signing endpoint, offline verifier ships with the key.

// 1. your engine's verdicts, normalized by the stream_fraud adapter
const batch = {
  pool_ctx: { pool: "global-premium", market: "US", period: "2026-05" },
  model_ref:  "mir:stream-integrity:v3",
  policy_ref: "policy:fraud-threshold:2026.05",
  events: streamVerdicts,   // [{track_id, stream_id, verdict, confidence}, ...]
};

// 2. build + sign — one ML-DSA-65 signature for the whole period
const { receipt, signing_payload, secrets } = buildReceipt(batch, { engine: "stream_fraud" });
const sig = await hiveSigner.sign(signing_payload);   // POST to the Hive signer

// 3. anyone verifies offline, no secret, no callback
const { ok, problems } = verify(receipt, sig, HIVE_PUBLIC_KEY);
// ok === true  ->  divisor basis is provable for this pool/market/period