Royalty operations
Royalties & commercial terms explains what a contract says is owed: the rate rules, the basis, the advance, the splits. This page is the other half of the story — the operations that make those terms come true as money actually moves. As sales land and AI surfaces serve answers, something has to price each one against the right contract, divide pooled revenue across the Works that earned it, recoup advances, close each period, and produce a statement every payee can check. That machinery is what we call royalty operations.
In design
The royalty model is settled: rates, basis, advances and splits are recorded on the Contract today, and the usage events that feed pool division are specified and captured now, at serve time. What is still being designed is the Royalty service that consumes them — accrual, pool division, recoupment, settlement, statements and payouts. The stages on this page describe the committed shape of those operations, not shipped behaviour; the event names shown below are illustrative, not yet claimed.
The pipeline at a glance
Every payout is the end of the same five-stage pipeline. Each stage has one job, and each stage's output is durable — which is what makes the final statement checkable.
flowchart LR
REC["Record<br/>sales + usage events"] --> ACC["Accrue<br/>price against contract"]
REC --> POOL["Divide<br/>consumption pools"]
ACC --> SET["Settle<br/>close the period"]
POOL --> SET
SET --> PAY["Pay<br/>statements + payouts"]
Two kinds of earning event
Money enters the pipeline from two directions, and the platform records each as events long before any royalty is computed.
Retail sales. First-party orders, subscriptions and refunds on Packt storefronts grant customers their entitlements and feed royalties. Each sale carries the dimensions the contract model prices on — format, channel, territory, language — along with what Packt actually received, priced under the catalogue the product was listed in. A refund is just a negative entry in the same ledger.
Usage. When an AI surface answers a reader, the platform records
one usage event per served response — platform.usage.content.v1.served
on the platform-usage bus. Its items list every passage the answer drew
on: which Resource and exact version, which
Work it belongs to, its rank in retrieval,
and whether it was actually shown to the reader or credited. The
event also pins the rights basis — the precise contract versions the
use was authorised under at the moment of serving. The full story is on
AI & your content and
Events & webhooks.
The crucial discipline: usage events record facts, never money. There is no royalty weight, no price, no share in a usage event — only what happened. Everything financial is computed later, from those facts, by the stages below.
Accrual: pricing each sale
For a retail sale, accrual is the contract model put to work. The sale arrives carrying its dimensions; the pipeline finds the governing contract, matches the sale against its rate rules, and picks the most-specific rule that applies — exactly the selection described on Royalties & commercial terms. The winning rate, applied to the contract's basis, becomes an accrual: a small ledger line naming the sale, the contract version, the rule that won, and the amount in integer micros.
Accruals are append-only. A correction is a new compensating line, not an edit — so the ledger always adds up to the statements it produced.
Dividing consumption pools
Subscription access and served AI surfaces do not have a per-item price to take a percentage of. They earn into a consumption pool: a pot of revenue for a period and a surface, which must be divided across every Work that was actually consumed.
The usage events are the ledger of that consumption. Dividing the pool is a two-step computation, and keeping the steps apart is deliberate:
- The facts come from the recorded events — which Works appeared in which answers, how often, at what rank, shown or merely consulted, credited or not.
- The division policy converts those facts into shares — how much more a passage shown to the reader counts than one consulted invisibly, how rank is weighted, whether credit earns a premium.
The policy is a versioned, tunable platform setting — not something baked into the events. Because the events carry only facts, tuning the policy never rewrites history: a candidate policy can be replayed over a past period and compared, line by line, with what the previous policy produced, before anyone adopts it.
The fairness property
Three guarantees compound here. Usage is recorded as facts at serve time, before anyone knows what the pool will be worth. The division policy is explicit, versioned and applied only at settlement. And every statement is reconstructible: given the events and the policy version, anyone with the right access can recompute a period and arrive at the same numbers. An author's share is an auditable calculation over recorded behaviour — never a figure that has to be taken on trust.
Recouping advances
An advance is money already paid, so it is the first claim on whatever a contract earns. The contract holds one advance pot, cross-collateralised across the whole agreement: accruals from every format, channel, territory — and every pool share — net against the same balance. While the balance is outstanding, earnings reduce it; once the contract has earned out, subsequent earnings flow through to the payees. The statement shows both sides: what was earned, and where the advance balance now stands.
Settlement, statements and payout
At the close of each period — the contract's payment frequency, most commonly quarterly — the pipeline settles: it fixes the pool totals, runs the division policy, nets accruals against advances, applies the contract's splits to whatever remains, and issues a statement per contract. The statement itemises retail accruals, pool shares with the policy version that produced them, advance movement, and the final split amounts — every line traceable back to recorded events. Payouts to payees then follow from the settled statements, never the other way round.
Commercial figures stay as private here as they are on the contract: statements and accruals are visible only to callers whose token is allowed to see commercial terms — the same rule the model page describes.
Illustrative events
The Royalty service will announce its milestones as platform events, following the platform's naming grammar described on Events & webhooks. These names are illustrative, not yet claimed — they show the shape, not a commitment:
| Illustrative event | Would announce |
|---|---|
platform.royalty.accrual.v1.recorded |
A sale or refund priced into the ledger. |
platform.royalty.period.v1.settled |
A period closed: pools divided, advances netted. |
platform.royalty.statement.v1.issued |
A statement finalised for a contract's payees. |
What is already real today is the input side: the
platform.usage.content.v1.served events feeding the pipeline are
specified, named and recorded now.
Related pages
- Royalties & commercial terms — the contract model this pipeline executes: rates, basis, advances, splits.
- AI & your content — how AI use is tracked, one usage event per served answer, in plain English.
- Events & webhooks — the event grammar, the platform buses, and how to consume platform events yourself.
- Catalogues — where the prices behind retail sales are set, per destination.
- Content Lake — the Works and Resources that usage events and royalty shares ultimately attach to.