# Reserve data API

ReserveBeat's read API serves the same stablecoin reserve figures this site renders: coverage read from issuer-published attestation reports, on-chain supply measured at an Ethereum RPC quorum, and the as-of date, source tier, and source document beside every value. Responses are JSON, the current state is served without a key, and figures are never adjusted.

Stablecoin reserve disclosures as structured data

The current state of every tracked stablecoin is served without a key: one unauthenticated GET returns the same figures this site renders. A free account and a key are needed only for depth over time. Neither step involves a sales call, an approval queue, or a minimum term.

ReserveBeat never estimates reserves. Between attestation dates it serves the last figure an issuer's report stated, carrying the as-of date that report stated it at — never a value modelled forward from it.

Reserve questions move at block speed and the answers sit in PDFs. An issuer states its figures in a periodic attestation report, but using them means downloading the document, finding the right table, and retyping numbers — again next period, for each issuer, with nothing that ties the number back to the line it came from.

ReserveBeat captures each report, hash-anchors it before parsing, and serves the stated figures as JSON alongside the as-of date, the source tier, and a link to the document they were read from. The rows this site renders are the rows the API returns, so a figure taken from the API traces back to a page here, and that page traces back to the issuer's own document.

Every endpoint is a GET, and every one but the evidence bundle, a zip archive, returns JSON. The current-state endpoints answer with no credential at all, so the request below runs exactly as written, from anywhere, with nothing to sign up for first. Depth over time carries a key instead, in the X-API-Key header; keys are issued from the dashboard, shown in full once at issue time, stored afterwards only as a one-way hash beside their prefix, and revocable at any time. A key that is presented is checked wherever it is presented, so a revoked one is refused even on an endpoint that would have answered the same request carrying none.

curl -s https://reservebeat.com/v1/board/tokens/USDC

{
  "symbol": "USDC",
  "issuer_name": "<issuer, as named in the report>",
  "chain": "ethereum",
  "attestation_status": "CURRENT",
  "coverage_series": [
    {
      "as_of": "<YYYY-MM-DD>",
      "report_month": "<YYYY-MM>",
      "total_reserve_usd": "<reserve figure, verbatim from the report>",
      "tokens_outstanding": "<liability figure, verbatim from the report>",
      "coverage_ratio": "<reserve / liability, 6 dp>",
      "source_tier": "ISSUER_ATTESTED",
      "source_sha256": "<hash of the captured document>",
      "source_url": "<the issuer's published report>"
    }
  ],
  "history_window_days": 30,
  "meta": {
    "disclaimer": "<the disclaimer at the foot of every page here, verbatim>",
    "terms": "https://reservebeat.com/terms@<version in force>"
  }
}

An abridged response. The field names and nesting are exactly what the endpoint returns, and the command above is the real one — run it and the bracketed slots come back filled. They are left bracketed here because a figure frozen into this page's copy would go stale against the record it was copied from, so no figure on this page is a ReserveBeat figure.

Every response carries a meta object beside the figures: the disclaimer this service publishes under, character for character the one at the foot of every page here, and the version of the terms in force. A response that cannot state both is refused rather than served without them.

The interface is also published as a machine-readable contract at https://reservebeat.com/v1/openapi.json. It is an OpenAPI document generated from the running service's own schema rather than written beside it, it covers the read endpoints and the account endpoints a key is issued from, and it is served without a key like the current-state endpoints themselves — so a client can be generated rather than hand-written, and it cannot describe a field the service does not have.

Current coverage for every tracked token, or one token in detail: the attested reserve and liability figures from the same report at the same as-of date, the ratio between them, independently measured on-chain supply, and the reconciliation of the two.

The parsed attestation inventory: every captured report by token and period, with its scope, its stated as-of dates, whether it supersedes an earlier parse, and the identifier of the stored artifact it was read from. A single report is fetched by token and period.

Coverage and supply over time as a series rather than a snapshot: a range set by from and to, a grain of hour, day or month that takes the last measurement in each bucket, and — when one token is named — that token's independently measured on-chain supply beside its attested coverage, every point still carrying the block it was read at and the tier it was read by. Any key reads any depth, metered in compute units, so a window reaching past the public thirty-day window costs more than one inside it; keyless reads, this site's pages among them, keep a rolling thirty-day window, where a request for more depth is refused outright rather than quietly truncated and the number of points behind the window is returned so the gap is visible.

The ten read endpoints are pull-only: nothing is pushed to a key with no balance, and a client that needs a current figure asks for it. An account holding a compute-unit balance, or on Enterprise, can also register HTTPS endpoints for two change notifications — attestation.landed, when an attestation report lands or is restated for a token, and figure.moved, when an issuer's own stated figure for a token changes. Every POST is signed with a per-endpoint secret that is shown once at registration and stored nowhere, every attempt is listed back on the account with the reason it failed, and a delivery can be replayed as the same bytes under a fresh timestamp — dedupe on `X-ReserveBeat-Delivery`; our replays carry `X-ReserveBeat-Replay-Of`. An account without a balance can register one endpoint that receives signed test pings only, so a receiver can be checked before buying; the signature, the test route and verification code are on the webhooks page. Measured on-chain supply is never pushed: it moves on every snapshot, and a notification here is a document landing rather than a ticker. Attestation alerts also remain available by email through the subscription form on this site.

Nothing on the revision log is pushed on its own. The free email alert, and the attestation.landed webhook sent to an account holding a compute-unit balance or on Enterprise, are sent when a report lands, an issuer's reissued report included; a corrected parse or a re-derived disclosure score is recorded on the log and sends neither. A reader who cited a figure re-checks the revision log for it.

The current-state endpoints are served without a key and are not metered per caller: no account, no monthly quota, and no per-key rate ceiling. Responses from them carry no quota or rate-limit headers, because there is no account for either to describe and a header naming a ceiling nothing enforces would be worse than none. A key sent to one of them anyway is verified, so a revoked key is still refused, and the call is recorded on the account's usage as unmetered — but it is never charged: it costs no compute units and takes nothing from the throughput budget, and the response is the same keyless one. What bounds them is capacity: a request that cannot be served inside it is refused rather than queued. The keyed tier — depth over time — is metered in compute units: 20,000 a month free, at a steady 20 compute units a second with up to 200 in any rolling 10 seconds. The limits belong to the account, not the key: every key an account issues shares them. Only responses the service actually served cost compute units. Quota and rate-limit state ride every served keyed-tier response in standard headers — the X-Quota and X-RateLimit headers, and the RateLimit-Policy and RateLimit headers of the IETF draft the documentation names by revision — so a client reads what it has left rather than guessing, and the counter resets at the start of each month in UTC. A refusal carries the same state as far as it can state it truthfully, under one rule: the two ceilings ride a response when the request presented a key to the keyed tier or presented a key that was refused, the seconds to the reset ride either way because they describe the calendar rather than the caller, and a remaining figure rides only where the service actually read it. A rate-limited refusal is answered before the monthly count is read, so it states the ceilings, the reset and the rate-limit remaining, without the quota remaining rather than reporting one it did not look up; a request that presented a key and was refused before it could be verified carries the ceilings and the reset and omits both remaining figures, because it never resolved an account to count for; a request under neither ceiling — no key at all, or a verified key on a keyless endpoint — carries the reset alone when it is refused, rather than naming a limit nothing is enforcing on it.

Those are the limits the service enforces today, not a marketing tier, and the compute-unit weights behind them are derived from measured serving cost rather than set by hand. Past the free allowance, compute units are paid as you go from a prepaid balance, which also raises the throughput; the pricing page states the rate.

The API publishes under the same review as the board. When the pre-publication review no longer covers the served methodology, figure endpoints refuse with an explicit withheld response that says so, rather than serving an unreviewed number — a withheld board is a withheld API, deliberately.

Access beyond the free allowance is bought in compute units — the pricing page states the rate — and an Enterprise arrangement is made by writing to contact@reservebeat.com, the same address that takes API bug reports.

ReserveBeat is not a rating agency. The disclosure score is a count of stated facts, not a credit rating and not an assessment of any token's safety.

ReserveBeat and its operator hold no position in any tracked token beyond incidental personal holdings, and take no payment from any issuer for the board or the API.

Run the request above against the live service with no key. When depth over time is what you need, create a free account from the dashboard and issue one.

## Disclaimer

ReserveBeat renders figures from issuer-published reports and public blockchains, verbatim and at their stated scope. It is not an auditor, makes no attestation, and states no opinion on any issuer's solvency. Nothing here is investment, trading, legal, tax, or accounting advice. No figure published here is a recommendation to hold, buy, sell, or redeem any token.

Tracked tokens are subjects of public data: supply figures are read from their public Ethereum contracts, and composition figures from the issuers' own published attestation reports. No tracked issuer is a customer and none has endorsed this site.

Source: https://reservebeat.com/api