The interfaces Stable Tape publishes

register

What is published, and on what terms

Not every interface below carries the same commitment. Three registers are used on this page, and each one is stated in words as well as by the rule beside the row, so the distinction survives print, greyscale and a cropped screenshot.

• Public. A supported read-only contract. CORS-open to any origin, documented here, and covered by the documentation test. Field names and units are not changed without changing this page.
• Research. Real and readable, but published as a research surface. The on-chain oracle is a second, independent publication of the same reading; it is not the citation surface and it carries no availability commitment.
• Internal. Reachable, but not offered as a public contract. Restricted to first-party origins, and listed here only so that an interface visible in a network log is explained rather than mistaken for something to build on.

Table scrolls horizontally →

what the benchmark is for

A maintained benchmark, not another raw feed

Stablecoin supply and U.S. M2 are both public, and both stay useful on their own. What DDD adds is the layer above them: one maintained number, computed from a fixed source selection with a fixed rounding and display rule, frozen into dated records, and carried forward unchanged when an upstream feed changes shape.

Stitching DeFiLlama and FRED together yourself means re-deriving that methodology and re-checking the rounding rule every time something moves upstream. The point of these endpoints is that a product, article, dashboard or agent can cite one number instead of re-deriving it. The full source selection and its caveats are on Methodology.

public · benchmark and records

Benchmark and record API

Three public read-only endpoints carry the benchmark itself. All are CORS-open to any origin, take no authentication, and return application/json.

$ curl -sS 'https://stabletape.com/api/ratio'

// Illustrative values. Every field the endpoint returns is shown.
{
  "dddPctRaw":           1.3308184918420052,   // unrounded PERCENT, not a 0-1 ratio
  "dddPctDisplay":       "1.33",                 // string, fixed 2dp
  "oneInN":              75,                     // round(100 / dddPctRaw)
  "stablecoinSupplyUsd": 308153683423,           // whole USD
  "usM2Usd":             23155200000000,         // whole USD
  "m2Date":              "2026-06-01",           // FRED M2SL observation date, always a month start
  "m2DateLabel":         "JUN 2026",
  "updatedAt":           "2026-08-06T12:04:11.318Z",
  "sources": {
    "stablecoins": "DeFiLlama",
    "m2":          "FRED M2SL"
  }
}

$ curl -sS 'https://stabletape.com/api/tape?window=daily'
$ curl -sS 'https://stabletape.com/api/tape?window=daily&date=2026-06-25'

$ curl -sS 'https://stabletape.com/api/tape?window=daily-history'

$ curl -sS 'https://stabletape.com/api/tape?window=daily-history&limit=90'

// illustrative values; each record is a reduced projection, newest first
{
  "status":  "ok",
  "count":   41,          // whole stored archive, not the returned page
  "records": [
    {
      "date":                 "2026-07-29",
      "from":                 "2026-07-28T12:00:00.000Z",
      "to":                   "2026-07-29T12:00:00.000Z",
      "netIssuerMovementUsd": -250060285,
      "expandedUsd":          426210093,
      "contractedUsd":        676270378,
      "benchmark": {
        "totalSupplyUsd": 308022276470,
        "m2Used":         23155200000000,
        "m2AsOf":         "2026-06-01",   // FRED M2SL reference month
        "sharePctRaw":    1.33025098,
        "sharePct":       1.33,
        "oneInN":         75
      },
      "canonical":    true,
      "recordStatus": "canonical"
    }
  ],
  "gaps": [
    { "date": "2026-07-30", "type": "gap", "reason": "noon_anchor_unavailable" }
  ]
}

public · structure

Structure endpoints

Three further public endpoints expose the structure layer that Methodology points here for. Each one backs the corresponding Structure route, is CORS-open, and is served with Cache-Control: public, s-maxage=300, stale-while-revalidate=600. Like /api/ratio, they are current snapshots rather than frozen records, so they are not a citation surface.

Table scrolls horizontally →

citation

Attribution guidance

Please attribute Stable Tape and link to the relevant dated Daily Tape record or to the methodology page when citing the benchmark.

• Benchmark: cite Digital Dollar Dominance (DDD) with a link to stabletape.com/methodology. DDD measures USD stablecoin supply as a share of U.S. M2. It is a supply-scale benchmark, not a complete adoption metric.
• Daily Tape records: dated, frozen records are the citable and shareable surface, and each carries a selected headline and its own dated card. Link to stabletape.com/tape and include the record date. Current readings from /api/ratio, from the widget or from the homepage are not citable until frozen as a dated record.
• Movement language: use expanded supply, contracted supply and snapshot-to-snapshot movement. Daily Tape is not a transaction-level mint or burn tracker unless on-chain event evidence is shown.
• Sources and caveats: stablecoin supply from DeFiLlama; U.S. M2 from FRED M2SL. M2 observations are revised by the Federal Reserve, and DDD uses the latest available. Data can be delayed or revised upstream. No SLA or uptime guarantee is implied.

public · embed

Embed widget

The widget is a single self-contained HTML document served at /widget. Drop it into any page as an iframe. It loads no script bundle, no web font and no stylesheet from anywhere, and it makes exactly one network request of its own: a read of /api/ratio when it loads. It is free to use and needs no key.

research · solana mainnet

The on-chain oracle

The DDD reading is also written to four accounts on Solana mainnet, so the number can be verified and consumed without trusting this site's HTTP layer. This is a research surface. It is a second publication of the same reading, not a separate measurement, and it carries no availability commitment: an on-chain read can be mid-cycle, and the accounts are updated by a single authority.

Reads are permissionless. No wallet, no transaction and no fee is involved; a single RPC getAccountInfo or getMultipleAccounts call is enough.

Table scrolls horizontally →

Each account is a program-derived address from its seed and the program ID, so any of them can be re-derived rather than trusted from this page.

// Read the DDD summary account from Solana mainnet.
import('@snowplow1337/ddd-oracle-sdk').then(async ({ readDDD }) => {
  const { Connection } = await import('@solana/web3.js');
  const conn = new Connection('https://api.mainnet-beta.solana.com');

  const s = await readDDD(conn);

  // dddPercent is precomputed; totalStablesUsd is a bigint in whole USD.
  console.log('DDD     = ', s.dddPercent.toFixed(4) + '%');
  console.log('Stables = $' + (Number(s.totalStablesUsd) / 1e9).toFixed(2) + 'B');
});

import urllib.request, json, base64, struct
from datetime import datetime, timezone

# Base58 encoder (no deps)
ALPH = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
def b58(b):
    n = int.from_bytes(b, 'big'); s = ''
    while n: n, r = divmod(n, 58); s = ALPH[r] + s
    return '1' * (len(b) - len(b.lstrip(b'\x00'))) + s

# Fetch all 4 oracle accounts in one RPC call
req = urllib.request.Request(
    'https://api.mainnet-beta.solana.com',
    data=json.dumps({
        "jsonrpc": "2.0", "id": 1, "method": "getMultipleAccounts",
        "params": [[
            "8DAncbbsEkmsCCakHpNK5zf49XLcWQrryTBYdjgcLWxA",  # summary
            "97g36T1PV3anxCwxV6ue5MmF2A9HQHMsLqevckrkqjzK", # chains
            "GznG6pxbLPrqeYDd5aFXJcXK5SQ4wXifBtqjep34DNe",  # issuers
            "7FRjdiN489qMU2R8G2RumBPxRjanY9683gnXttKP4Fhv",  # tokens
        ], {"encoding": "base64"}],
    }).encode(),
    headers={'Content-Type': 'application/json'},
)
r = json.loads(urllib.request.urlopen(req).read())['result']['value']
s, c, ib, t = (base64.b64decode(a['data'][0]) for a in r)
ts_utc = lambda u: datetime.fromtimestamp(u, tz=timezone.utc).isoformat()

# Summary account, offset 73 onward: ddd, total_stables_usd, m2_usd, timestamp, slot, sequence
ddd, stb, m2, ts, slot, seq = struct.unpack_from('<QQQqQQ', s, 73)
# Concentration fields follow the three u8 counts at 121/122/123.
hhi, eff, top = struct.unpack_from('<III', s, 124)

print(f"DDD ratio : {ddd/1e4:.4f}%")          # raw / 1e4 == percent
print(f"Stables   : ${stb/1e9:,.4f}B")        # whole USD, so /1e9 == billions
print(f"U.S. M2   : ${m2/1e12:,.4f}T")
print(f"Issuer HHI: {hhi}  (effective {eff/1e6:.2f}, top {top/1e6:.2f}%)")
print(f"Updated   : {ts_utc(ts)}  (slot {slot:,})")
print(f"Sequence  : {seq}")
print(f"Admin     : {b58(s[8:40])}")

# Book accounts: count at byte 25, then fixed 29-byte entries from byte 26.
def read_book(name, d):
    cnt = d[25]
    print(f"\n--- {name}  (count={cnt}) ---")
    for k in range(cnt):
        o = 26 + k*29
        nm = d[o+1:o+1+d[o]].decode('utf-8', errors='replace')
        sup, pct = struct.unpack_from('<QI', d, o+17)
        print(f"  {k+1:<3} {nm:<16} ${sup/1e9:>10,.2f}B  {pct/1e6:.4f}%")

read_book('CHAINS',  c)
read_book('ISSUERS', ib)
read_book('TOKENS',  t)

# Static example. This page runs no browser-side RPC call of its own:
# third-party RPC endpoints set their own CORS and CSP rules, so a
# documentation page is the wrong place to read from one. Run the
# snippet above from a server or a shell for real values.
DDD ratio : 1.3500%
Stables   : $305.0000B
U.S. M2   : $22.5900T
Issuer HHI: 3120  (effective 3.21, top 61.40%)
Updated   : 2026-08-06T12:00:00+00:00  (slot ...)
Sequence  : ...

$ curl -sS https://api.mainnet-beta.solana.com \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getAccountInfo",
    "params": [
      "8DAncbbsEkmsCCakHpNK5zf49XLcWQrryTBYdjgcLWxA",
      { "encoding": "base64", "commitment": "confirmed" }
    ]
  }'

$ curl -sS 'https://api.mainnet-beta.solana.com' -X POST \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"getAccountInfo","params":["8DAncbbsEkmsCCakHpNK5zf49XLcWQrryTBYdjgcLWxA",{"encoding":"base64","commitment":"confirmed"}]}' \
| python3 -c '
import sys, json, base64, struct
from datetime import datetime, timezone
j = json.load(sys.stdin)
raw = base64.b64decode(j["result"]["value"]["data"][0])
ddd, stb, m2, ts, slot, seq = struct.unpack_from("<QQQqQQ", raw, 73)
print("DDD %     ", round(ddd / 1e4, 4))
print("Stables   ", "${:.2f}B".format(stb / 1e9))
print("U.S. M2   ", "${:.2f}T".format(m2 / 1e12))
print("Updated   ", datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M UTC"))
print("Slot      ", slot)
print("Sequence  ", seq)
'

agent workflows

Using DDD with agents

People often pick a stablecoin by habit, brand or chain loyalty. An agent can read the structure instead. The endpoints above expose the benchmark, issuer concentration and chain distribution in machine-readable form, which is the input an allocation or routing decision actually needs.

• Treasury

  Check issuer concentration — HHI, effective issuer count, top issuer share — before recommending a stablecoin allocation.

• Risk monitoring

  Watch for concentration rising: the same three fields, sampled over time from /api/v1/oracle/summary or /api/issuers.

• Payment planning

  Use chain distribution to decide where stablecoins should move. Velocity data is research-stage and is not exposed here.

• Research

  Read the dated records directly from /api/tape instead of scraping a dashboard that may re-render.

DDD decides. Execution providers execute.

limits and guarantees

What is and is not promised

• No SLA. These endpoints are published without an uptime, latency or availability guarantee. Cache what you need and degrade gracefully. Every public endpoint here is CDN-cached, so treat the cache window as the real freshness bound.
• Upstream revision. DeFiLlama restates supply and the Federal Reserve revises M2. A current reading can change under you; a frozen dated record cannot. That is the reason to cite records rather than readings.
• Update cadence. The Daily Tape record is cut at 12:00 UTC. /api/ratio and the structure endpoints recompute per request behind a five-minute cache. The oracle follows its own write cycle and stamps timestamp, slot and sequence so you can see exactly how old a read is.
• No fees on chain. Reading Solana accounts costs nothing. You only pay lamports to write, which reading the ratio never requires.
• RPC endpoints. Every snippet here uses the public cluster api.mainnet-beta.solana.com, which is rate-limited and not intended for production. Use your own provider. This page itself makes no RPC call: the example output above is a static illustration, not a live read.
• Change policy. If a documented field name, unit or scale changes, this page changes with it, and npm run test:developer-api-docs fails until it does. Interfaces in the research and internal registers carry no such commitment.