Products
Data Access Portal API SQD Network Supported Chains
Development SDK SQD Cloud SQD 360
Solutions
By Use Case DeFi & Trading Analytics AI Agents Wallets & Payments Compliance All Solutions
By Industry Stablecoins RWA All Customers
Developers
Get Started Documentation Subsquid Subsquid Labs Dev Chat
Resources
Learn Guides Compare Blog Videos Changelog
Company About Ecosystem Brand Assets
Customers Pricing
Talk to us
Home / Solutions / Stablecoins
Stablecoins

Stablecoin data across every chain: transfers, mint and burn, and peg

Onchain, every stablecoin movement is a Transfer event: a mint is a transfer from the zero address, a burn is a transfer to it, a payment is one between two wallets. SQD serves that transfer and swap data across 225+ networks, the substrate for flow tracking, supply series, and peg monitoring.

Talk to us How stablecoin data works
225+ Networks
Mint + burn From transfers
Cross-chain Time-aligned
Any token ERC-20 + SPL
Trusted by leading teams
zkVerify GMX Morpho PancakeSwap Deutsche Telekom RAILGUN
zkVerify GMX Morpho PancakeSwap Deutsche Telekom RAILGUN
zkVerify GMX Morpho PancakeSwap Deutsche Telekom RAILGUN
The problem

A stablecoin dashboard is a data product: flow, supply, and peg are all read back off the chain

Flow, supply, and peg are not separate feeds you subscribe to; each is read back off the same onchain Transfer and Swap events. Rebuilt the naive way, that means a per-chain address map because a stablecoin is a separate native deployment on every network, time-aligning windows across chains where the same block height is a different wall-clock moment, and folding mints minus burns into a supply series by hand. It is all onchain already; the cost is in reading it consistently across every chain the token lives on.

How it works

Every movement is a Transfer event

Issuance, redemption, and every payment are the same queryable Transfer event. Filter it for a stablecoin's contract and you have its entire flow of funds on that chain, no separate supply feed, no aggregator.

One real result from the USDC query on the right, at block 21,000,100, is an issuance: the sender is the zero address, so these are new tokens entering circulation, paid to 0xa622…4974.

from: 0x0000000000000000000000000000000000000000
to: 0xa6227fffd0f7e46ee9f513ca65acfd52667f4974
value: 750.969553 USDC (a mint)

The query is one filter on the token address and the Transfer topic. Sender is in topic1, recipient in topic2, amount in data:

USDC transfers on Ethereum
POST https://portal.sqd.dev/datasets/ethereum-mainnet/stream
{
"type": "evm",
"fromBlock": 21000000,
"toBlock": 21000100,
"logs": [{
"address": ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"],
"topic0": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"]
}],
"fields": {
"block": { "number": true, "timestamp": true },
"log": { "address": true, "topics": true, "data": true, "transactionHash": true }
}
}
Cross-chain

The same query on every chain, with two gotchas

A stablecoin is rarely one thing on one chain. The same Transfer query runs on every network SQD indexes, but two things have to be right. First, the contract address is a separate native deployment per chain, so a cross-chain query carries a per-chain address map; using one address everywhere silently returns nothing on the others.

ChainUSDC contract
  • Ethereum0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
  • Base0x833589fcd6edb6e08f4c7c32d4f71b54bda02913
  • Arbitrum0xaf88d065e77c8cc2239327c5edb3a432268e5831

Second, block numbers are not comparable across chains: the same height is a different wall-clock moment on each one. To compare a window you resolve the timestamp to a block on each chain first, with one GET (/datasets/{chain}/timestamps/{unix}/block). For a fixed ten-minute window (2025-06-01 00:00 to 00:10 UTC), that same ten minutes is 49 blocks on Ethereum and 2,367 on Arbitrum, and the USDC transfer counts only compare because the windows are time-aligned:

Chain00:00 blockBlocksUSDC transfers
  • Ethereum22,606,143491,304
  • Base30,973,32730010,483
  • Arbitrum342,607,9692,3673,649
USDC transfers, 2025-06-01 00:00:00 to 00:10:00 UTC, time-aligned per chain

Base moved USDC close to eight times as often as Ethereum in that window. With an RPC node you would binary-search block timestamps instead, roughly twenty calls per bound, per chain. The full walkthrough is in the stablecoin data guide.

What the data is, and isn't

Transfers and trades, not reserves or balances

Supply is reconstructed

There is no cross-chain supply field to read. Circulating supply is the running total of mints (transfers from the zero address) minus burns (transfers to it), summed across every chain. SQD serves the mint and burn transfers; you fold them into the series.

Peg is a trade price, reserves are off-chain

Peg health is the executed price on the deepest DEX pools versus 1.00, read from Swap events, a monitoring signal, not an oracle. Issuer reserve attestations are off-chain and not indexed; pair onchain data with the issuer's published reports.

Coverage

Every major stablecoin, every deployment chain

SQD does not maintain a curated list of "supported" stablecoins. Any ERC-20 Transfer event on any of 225+ networks is queryable, including stablecoins that launched yesterday and newer stablecoin-focused chains like Plasma.

USDC Circle Native deployment per chain, each its own contract address
USDT Tether Multi-chain native and bridged issuance
DAI / USDS MakerDAO / Sky Decentralized issuance with onchain governance data
FRAX Frax Finance Collateralized and algorithmic, with AMO contract data
GHO Aave DeFi-native stablecoin with facilitator-level mint tracking
Any ERC-20 Any issuer Query any token contract, no whitelist, no approval process
Capabilities

Built for Stablecoins at scale

Cross-chain flow tracking

The same Transfer query runs on every chain a stablecoin is deployed on; the only change is the per-chain contract address. USDC is a separate native deployment on Ethereum, Base, Arbitrum, and more, so a cross-chain flow is transfers in several datasets, joined on address and amount.

Mint and burn monitoring

A mint is a Transfer from the zero address; a burn is a Transfer to it. Stream both from Circle, Tether, MakerDAO, and any issuer as they confirm onchain, then fold mints minus burns into a circulating-supply series.

Peg signals from DEX trades

A stablecoin's peg is the price it trades at, not a contract field. Read the executed price from Swap events on its deepest pools and compare to 1.00; a sustained gap is a depeg signal. This is a trade-price read, not an oracle and not a reserve attestation.

Velocity and concentration metrics

Compute transfer velocity, unique holder counts, and concentration ratios at the wallet level from decoded transfers. The data comes typed; you write the analytics logic, not the data pipeline.

Why SQD

What you would build yourself

Flow, supply, and peg are read back off the same onchain events; the work a provider saves is in reading them consistently across every chain.

  • Cross-chain windows
    Yourself Block heights are not comparable across chains, so aligning one time window means binary-searching timestamps on an RPC node, roughly twenty calls per bound, per chain.
    With SQD One GET resolves each chain's timestamp to a block, so the same wall-clock window is time-aligned across every chain before you query.
  • Flow of funds
    Yourself Assemble a token's flow from a separate supply feed and an aggregator.
    With SQD One filter on the Transfer event and the token's contract returns the entire flow of funds on that chain: sender, recipient, amount, and block timestamp.
  • Circulating supply
    Yourself No single onchain field holds cross-chain circulating supply.
    With SQD The mint transfers from the zero address and the burn transfers to it arrive from every chain; you fold mints minus burns into a supply series.
  • Peg signal
    Yourself Peg health is a market price, not a contract field you can read.
    With SQD The executed price off the deepest DEX pools' Swap events, compared to 1.00, is a depeg signal.

See this on your own contracts

Tell us the chains and contracts you care about, and we will show you the query that returns them.

Talk to us Try the public API
Use cases

What teams build with SQD

  • Stablecoin flow and supply dashboards
  • Depeg early warning from DEX swap prices
  • Cross-chain adoption and velocity reports
  • Mint and burn monitoring for treasuries and market makers
  • Regulatory reporting feeds from decoded transfers
  • Payment and settlement reconciliation
Background reading
What is a Tron indexer?

Tron's TVM emits the same event topics as Ethereum, so decoding is identical, but the request type, the typed-transaction schema, and the energy and bandwidth model differ. The data model, a real TRC-20 query, and what carries over from EVM.

USDT on Tron: querying the largest stablecoin rail

Tron settles more USDT than any other chain. Pull TRC-20 USDT transfers from the Portal in one declarative query, read a real transfer end to end, and see why the energy and bandwidth model lets transfers settle without burning TRX.

TRC-20 vs ERC-20: one token standard, two chains

TRC-20 mirrors ERC-20: the same Transfer event, the same topic0 hash, so a decoder built for one reads the other unchanged. What actually differs is the chain envelope: address format, native token, fees, finality, and how you fetch the data.

Stablecoin data: tracking cross-chain flows and peg health

Following stablecoin transfers across every chain they live on with one query model, aligning windows across chains by timestamp, and reading peg health from DEX trades.

What is onchain analytics?

How blockchain history feeds analytics dashboards. The data pipeline, the common metrics, and how this is done in tools like Dune and in-house BI.

Frequently asked questions

How do you track stablecoin flows onchain?
Onchain, every stablecoin movement is a Transfer event, so the flow of funds is the Transfer log filtered to the token's contract: sender, recipient, amount, and block timestamp. Point a query, or a Squid SDK indexer, at the stablecoin's contract on each chain and you get the full flow for that token, with the same shape on every chain it is deployed on.
How do you measure stablecoin supply onchain?
Supply is reconstructed, not read from a single field: a mint is a Transfer from the zero address, a burn is a Transfer to it, and circulating supply is the running total of mints minus burns across every chain the token lives on. SQD serves the mint and burn transfers; you fold them into a supply series with a Squid SDK indexer.
Can I get stablecoin reserve data?
Off-chain reserve attestations from issuers (Circle, Tether, MakerDAO) are not onchain, so SQD does not index them. What is onchain, mints, burns, transfers, and collateral-contract events, SQD serves; pair it with the issuer's published attestations for a full reserve picture. SQD reads the chain, not the audit report.
How do you read a stablecoin's peg from onchain data?
Peg health is a market price, not a contract field. Read the executed price from Swap events on the stablecoin's deepest DEX pools and compare it to 1.00; a sustained gap is a depeg signal. It is a reading of trade data for monitoring, separate from an oracle feed and not a settlement price.

Other ways teams use SQD

See all solutions
RWA

Issuance, transfers, and the issuer control events a token API omits.

Decentralized Exchanges

Pool discovery from factory events, and every trade the pools emit.

Gaming

Item ownership, game currencies, and marketplace settlement onchain.

SocialFi

Registrations, delegation, and the social graph that stays onchain.

Memecoins & Token Launches

Deployments as CREATE traces, LP creation, and the first trades.

Get started

Your blockchain data infrastructure, handled.

Private Portal. Dedicated. Validated. Managed. Tell us what you're building, we'll show you what it looks like on SQD.

Talk to Us Try the Public API