Blueprint Canton Chain API

The complete Canton Network transaction record over one REST API. Every Canton Coin transaction since genesis (June 2024) is indexed on Blueprint's own validator infrastructure and exposed with per-party resolution — the query surface the chain itself does not offer.

Canton's public Scan API serves a single global feed with no per-party filter, and a participant's Ledger API only sees parties it hosts. Blueprint's index closes that gap: any transaction, any party, any balance — cursor-paginated, filterable, and seconds behind the chain head.

What you can query

Global feed — hundreds of millions of transactions from genesis, filterable by type, mining round, or calendar day.
Any party's history — complete, in either direction, with the party's role in every transaction. No wallet, node, or hosting relationship required.
Live balances & holdings — point-in-time ACS snapshots: unlocked/locked coin, accrued holding fees, active holding contracts.
Rounds, names, network — mining-round activity, the ANS directory, DSO and super-validator metadata, current CC fee configuration.
Aggregates & market data — daily transaction and CC-volume series, plus CC price and market cap.

How it works

The global feed is ingested continuously (~seconds behind head), normalized per party into Postgres, and served read-only. Point-in-time state — balances, holdings, ANS, network config — is passed through live from the Super Validator Scan API.

Base URL: https://ccscan.xyz — all endpoints are read-only GETs returning JSON. Machine-readable spec at /openapi.json, interactive explorer at /api-docs/.

Getting Started

No SDK or signup needed to evaluate — the API speaks plain HTTPS + JSON:

# Chain head + the 12 newest transactions
curl -s https://ccscan.xyz/api/overview

# Page the global feed, newest first
curl -s "https://ccscan.xyz/api/txs?limit=50"

# One transaction, by seq or event id
curl -s https://ccscan.xyz/api/tx/320000000

# Find a party, then pull its full history and live balance
curl -s "https://ccscan.xyz/api/party/search?q=cumberland"
P="Cumberland-1::12201aa8a23046d5740c9edd58f7e820c83e7f5c58f25551f955f3252d3a04240860"
curl -s "https://ccscan.xyz/api/party/$P/txs?before_seq=0&limit=100"
curl -s "https://ccscan.xyz/api/party/$P/balance"

Reconciliation loop in four lines: read next_after_seq from each page and persist it — the cursor is stable across restarts and retries.

after=0
while true; do
  page=$(curl -s "https://ccscan.xyz/api/party/$P/txs?after_seq=$after&limit=100")
  # process $page, then:
  after=$(echo "$page" | jq .next_after_seq)
  [ "$(echo "$page" | jq .count)" = 0 ] && sleep 30
done

Authentication & Plans

Browsing is open — the API answers unauthenticated requests at an anonymous, per-IP rate so the explorer and quick evaluation just work. For production and programmatic use, authenticate with an API key to unlock a higher plan.

Send your key on every request as either header:

curl -H "Authorization: Bearer cck_your_key_here" \
  https://ccscan.xyz/api/overview

# or
curl -H "X-API-Key: cck_your_key_here" \
  https://ccscan.xyz/api/overview

Plans

Tier	Rate limit	For
Anonymous	120 req/min (per IP)	Browsing & evaluation — no key
Free	300 req/min	Low-volume apps & prototyping
Pro	3,000 req/min	Production integrations
Enterprise	30,000 req/min	High-volume / dedicated workloads

Live tier details are also available at GET /api/plans. Need a key or a custom limit? Contact Blueprint.

Rate-limit headers

Every API response reports your current budget:

Header	Meaning
`RateLimit-Limit`	Requests allowed in the current window
`RateLimit-Remaining`	Requests left in the window
`RateLimit-Reset`	Seconds until the window resets
`X-Plan`	The plan applied to this request

Exceeding your limit returns 429 Too Many Requests with a Retry-After header (seconds). An invalid or revoked key returns 401. Back off and retry after the window resets.

Cursors & Pagination

Every transaction carries a monotonic integer seq assigned at ingest — the universal cursor. List endpoints return up to limit rows (max 100) and a cursor for the next page:

Direction	Request param	Response cursor	Semantics
Newest first	`before_seq`	`next_before_seq`	Rows with `seq < before_seq`; `0` = start at the newest
Oldest first (party history)	`after_seq`	`next_after_seq`	Rows with `seq > after_seq`; `0` = start at genesis

One monotonic cursor, two directions: before_seq walks backward from the head (start at 0), after_seq walks forward from genesis. Chain the returned next_*_seq to fetch the next page.

Cursors are deterministic: no gaps, no overlap, safe to chain across retries.
count: 0 means the range is exhausted (head reached, or the party's first transaction).
after_seq and before_seq are mutually exclusive — sending both returns 400.

Transactions

GET/api/txs

The global feed, newest first. Filters compose freely:

Param	Type	Description
`before_seq`	int	Cursor; 0/omitted = newest
`type`	enum	`transfer` · `mint` · `tap` · `abort_transfer_instruction`
`round`	int	Limit to one mining round
`day`	date	Jump to a UTC day (`YYYY-MM-DD`) — resolved by binary search over the seq key, ~30 index probes
`limit`	int	Default 25, max 100

GET/api/tx/{key}

One transaction by seq (digits) or full event id. Returns the list shape plus detail — the complete financial body: sender with input amount and fees, every receiver with amounts and receiver fees, balance changes with per-party deltas and holding-fee rates, transfer kind, and the ledger offset.

Parties

Parties are Canton identities of the form name::fingerprint. URL-encode the full id in paths. Around 400,000 parties have appeared on-chain; all are queryable.

GET/api/party/search?q=…

Case-insensitive substring search over every party ever seen (min 2 chars, up to 50 matches).

GET/api/party/{party}/summary

First/last activity with seqs, transaction count (exact to 100,000, then tx_count_capped: true), and the party's ANS entry when registered.

GET/api/party/{party}/txs

The party's complete history from genesis, forward (after_seq) or backward (before_seq), optionally filtered by type. Each row adds roles — how this party appears in that transaction (sender / receiver / balance_change).

GET/api/party/{party}/balance

Live balance at the most recent valid ACS snapshot: total_unlocked_coin, total_locked_coin, total_coin_holdings, accrued holding fees, and total_available_coin (holdings − fees). Amounts are decimal strings with 10 dp. summary: null = no CC held at the snapshot.

GET/api/party/{party}/holdings

The active Amulet holding contracts behind that balance (amounts, lock state), page size 200 with the Scan after token.

GET/api/party/{party}/validator

Whether the party is a validator, super-validator, and/or app-provider (from the reward types it collects), plus a liveness assessment (active ≤6h since last reward claim, lagging ≤24h, stale ≤7d, inactive >7d), recent reward performance (a fast bounded scan of the latest transactions), and exact lifetime reward totals (a cached full-history scan; lifetime.complete=false only if the history is too large to total in real time). Liveness is a reward-claim-recency heuristic.

Balances vs. history: balances are point-in-time snapshots; the transaction index stores per-transaction balance changes. Together they give a full audit trail: reconcile any party's balance from genesis, then verify against the live snapshot.

Rounds

GET/api/round/{round}

One mining round (~10 minutes each): tx_count, first/last seq, start and end times, plus a newest-first page of the round's transactions (same cursor semantics). Some automation records carry round 0 — they are indexed but do not belong to a user-facing round.

Names (ANS)

GET/api/ans?prefix=…&page_size=…

Canton Name Service directory entries — name, the user party id it resolves to, url/description, and expiry. Prefix filter is lowercased server-side; page size up to 1000. Reverse lookup (party → name) is included in the party summary.

Network

GET/api/network

One call for network metadata: DSO state (party id, voting threshold, SV node states), the super-validator scan directory, Splice instance names, Scan version, and the current AmuletRules payload — the authoritative CC fee schedule and traffic limits.

Stats & Market

GET/api/stats/daily

Per-day series from genesis: transaction counts by type and CC volume (transferred/minted/tapped), aggregated from the full index. While the one-time backfill is completing, complete: false and days appear oldest-first; progress = aggregated_to_seq / head_seq.

GET/api/stats/recent?days=14

Always-current per-day counts for the trailing 1–30 days, computed live against the index (10-minute cache). The final entry is the current partial day (partial: true).

GET/api/price

Canton Coin market data: USD and BTC price, market cap, 24h change (CoinGecko, 120s cache). Degrades to available: false rather than failing.

Search

GET/api/search?q=…

One box for everything. The classifier recognizes sequence numbers and round numbers (digits), event ids, exact party ids (::), party-id fragments, and ANS name prefixes — returning up to 20 typed results with the key to feed the matching endpoint.

Data Model

Transaction row

{
  "seq": 320000000,          // monotonic cursor, assigned at ingest
  "event_id": "#1220ce…:0",  // Canton event id, globally unique
  "round": 103286,           // mining round (0/null on a few records)
  "tx_type": "transfer",     // transfer | mint | tap | abort_transfer_instruction
  "tx_date": "2026-07-06 03:16:12.337540+00:00",
  "amount": 1.0,             // headline CC per `nature`; null only for aborts
  "nature": "send",          // send | reward | self | mint | tap | abort | other
  "rewards": null,           // validator+SV+app rewards claimed, when nature=reward
  "parties": { "<party>": ["sender"], "<party>": ["receiver"] },
  "kind": "preapproval_send" // transfer_kind, when the type is transfer
}

Transaction types

Type	Meaning
`transfer`	CC moved on-ledger. The `nature` field refines it: `send` (to a distinct receiver), `reward` (a validator / super-validator / app-provider collecting rewards into its own balance — no separate recipient), or `self` (a self-transfer / coin merge). Every transfer moves value — `amount` is the headline for that nature. `kind` further distinguishes direct transfers, pre-approved sends, and transfer-instruction flows.
`mint`	New CC issued to a party.
`tap`	Faucet-style issuance — defined for DevNet-originated economics; not observed on Canton MainNet (0 to date).
`abort_transfer_instruction`	A pending transfer instruction was aborted.

Roles

A party appears in a transaction as sender, receiver, and/or balance_change (its holdings were touched — e.g. fees or change). Roles come from the indexed per-party join, so history queries are exact, not heuristic.

Amounts

The chain records amounts as 10-dp decimal strings; the API's amount headline field is a JSON number for convenience, while detail and balance endpoints preserve the original decimal strings for accounting-grade use.

Freshness & Sources

Data	Source	Freshness
Transactions, parties, rounds, search	Blueprint's chain index (validator infrastructure)	Continuously ingesting; typically seconds behind head — verify via `ingest_cursor_at` in `/api/overview`
Balances, holdings, ANS, network	SV Scan API pass-through	Live, short server-side cache (30s–1h by endpoint)
Daily aggregates	Index post-processing	`/api/stats/recent` always current; `/api/stats/daily` backfilling from genesis
Market data	CoinGecko	120s cache

Errors

Errors are JSON with an error message and a conventional status:

Status	Meaning
`400`	Invalid parameter (unknown `type`, both cursors at once)
`404`	Transaction, party, round, or page not found
`502`	The Scan API upstream did not respond — retry shortly
`503` + `building: true`	A supporting index is still building — retry in minutes

Unknown parties in search-style endpoints are not errors: they return count: 0.

Agents & Discovery

/openapi.json — OpenAPI 3.1, the authoritative machine-readable contract.
/api-docs/ — interactive explorer with runnable requests.
/llms.txt — compact plain-text orientation for LLM agents.

Responses are flat, stable JSON with integer cursors — designed to be trivially consumed by agent frameworks and reconciliation pipelines alike.

Access & Commercial

The API is open for evaluation. For production workloads — commercial terms, rate guarantees, SLAs, dedicated read capacity, or custom endpoints (webhooks, bulk export, bespoke aggregates) — talk to Blueprint:

theblueprint.xyz — company, platform, and contact.
The same infrastructure powers Blueprint's institutional reconciliation pipelines — the endpoints documented here are the ones we run in production ourselves.