andrew142/stablecoin-payments-eth

Stablecoin Payments on Ethereum (USDT, USDC, PYUSD)

Every USDT, USDC and PYUSD transfer on Ethereum from January 2024 to September 2026: 732,947,031 transfers, the 408,671,656 transactions behind them, and every block in the period. Compressed Parquet, 57.7 GB, one folder per day.

Built with an open pipeline: github.com/Andreas142/twinfault. Dashboards built from it: andreas142.github.io/twinfault. It is the clean baseline for twinfault, a benchmark that tests whether AI analysts can tell a broken data pipeline from a real business change.

Tables

Pick a table with the dropdown in the Dataset Viewer, or by name in code.

Table	Rows	What one row is
stablecoin_transfers	732,947,031	One token transfer
stablecoin_transactions	408,671,656	One Ethereum transaction that moved a stablecoin or called a token contract
blocks	7,184,843	One Ethereum block
load_manifest	3,012	One source table on one day: rows, files, block range and write delay

Coverage: Ethereum mainnet, 1 January 2024 to 30 September 2026, 1,004 days.

Token	Contract address
USDT	0xdac17f958d2ee523a2206206994597c13d831ec7
USDC	0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
PYUSD	0x6c3ea9036406852006290770bedfcaba0e23a0e8

Monthly transfers grew more than sevenfold over the period, from 6,982,641 in January 2024 to 52,911,528 in June 2026.

Daily marts

Small daily tables built from the four tables above by the project's dbt models, one Parquet file per month under marts/. A month is published only after all its dbt tests pass, including a check that the payments cube adds up to the raw transfers exactly.

Table	What one row is
fct_daily_payments	One day, token, amount band (under 10, 10 to 1k, 1k to 100k, 100k and over) and route (direct or via contract): transfers, volume, and approximate counts of transactions, senders and receivers
fct_daily_token_health	One day and token: direct calls to the token contract, failed calls, failure rate, median and total fee in ETH
fct_daily_pipeline	One day: blocks, missing and duplicate blocks, average base fee, stablecoin transfers, source rows and files, and the longest load delay

Approximate counts use HyperLogLog and are valid within a row only; do not add them across rows.

Quick start

DuckDB reads the files straight from Hugging Face, with no download:

SELECT date_trunc('month', date) AS month, token,
       count(*) AS transfers, sum(amount) AS volume
FROM 'hf://datasets/andrew142/stablecoin-payments-eth/stablecoin_transfers/*/*.parquet'
WHERE date >= DATE '2026-01-01'
GROUP BY ALL
ORDER BY ALL;

Python, streaming so nothing large is downloaded:

from datasets import load_dataset

transfers = load_dataset("andrew142/stablecoin-payments-eth", "stablecoin_transfers",
                         split="train", streaming=True)
print(next(iter(transfers)))

Columns

stablecoin_transfers

Column	Type	Meaning
date	date	Day of the block (UTC); also the folder name
block_timestamp	timestamp	Block time (UTC)
block_number	int64	Block height
log_index	int64	Index of the transfer event; with transaction_hash it identifies a transfer uniquely
transaction_hash	string	Transaction that emitted the transfer; joins to stablecoin_transactions.hash
token	string	USDT, USDC or PYUSD
from_address	string	Sender, lower-case hex, stored as a 32-byte word: 0x, 24 zeros, then the 20-byte address. Mints come from the zero address
to_address	string	Recipient, in the same 32-byte form. Burns go to the zero address
amount	float64	Amount in tokens (raw value ÷ 10^6; all three tokens use 6 decimals)
last_modified	timestamp	When the source row was written to the AWS bucket

stablecoin_transactions

Two kinds of transaction are included:

1. every transaction that emitted at least one stablecoin transfer;
2. every transaction sent straight to one of the three token contracts, including failed ones.

A failed (reverted) transaction emits no transfer events, so failures are only visible through the second kind.

Column	Type	Meaning
date	date	Day of the block (UTC)
block_timestamp	timestamp	Block time (UTC)
block_number	int64	Block height
transaction_index	int64	Position of the transaction in its block
hash	string	Transaction hash
from_address	string	Account that sent the transaction, lower-case hex
to_address	string	Contract or account called, lower-case hex
direct_token	string	USDT, USDC or PYUSD if the transaction called that token contract directly; empty if it moved stablecoins through another contract, such as an exchange
receipt_status	int64	1 succeeded, 0 failed
receipt_gas_used	int64	Gas used
receipt_effective_gas_price	int64	Price paid per unit of gas, in wei. Fee in ETH = receipt_gas_used × receipt_effective_gas_price ÷ 10^18
transaction_type	int64	Ethereum transaction type
last_modified	timestamp	When the source row was written to the AWS bucket

blocks

Column	Type	Meaning
date	date	Day of the block (UTC)
number	int64	Block height
hash	string	Block hash
parent_hash	string	Hash of the previous block
timestamp	timestamp	Block time (UTC)
transaction_count	int64	Transactions in the block
gas_used	int64	Gas used by the block
gas_limit	int64	Gas limit of the block
base_fee_per_gas	int64	Base fee, in wei
last_modified	timestamp	When the source row was written to the AWS bucket

load_manifest

What a warehouse load log would record. One row per source table per day.

Column	Type	Meaning
source_table	string	token_transfers, transactions or blocks in the AWS source
date	date	Day loaded
rows	int64	Rows in the source that day, before filtering to stablecoins
files	int64	Source files that day
min_block, max_block	int64	Block range
first_written, last_written	timestamp	When the day's rows were written to the bucket
median_lag_s, max_lag_s	float64, int64	Seconds between block time and write time

The source loads one file per table per day. On a normal day rows land a median of about 12 hours, and at most about 24 hours, after their block. On 61 of the 1,004 days the source wrote the day much later or rewrote it afterwards, in all three tables at once: 44 days were first written more than two days late, up to about a year, and 17 were written on time and then patched. first_written and last_written show which days.

Investigations

Result tables behind the Investigations page, in investigations/: one Parquet file per check, plus report.md with every table in readable form. They cover four cases: the USDC and USDT failure spike of November 2025, the PYUSD failure spikes of August and September 2024, the 600-trillion PYUSD day of 15 October 2025, and the days the source rewrote. Produced by scripts/investigate.py.

Quality checks

Every month passed all seven checks before it was published:

1. every day of the month is present;
2. no duplicate transfers (same transaction hash and log index);
3. no transfer is missing an amount or an address;
4. every transfer's transaction is present;
5. every transfer's block is present;
6. no block number is missing from the month's range;
7. no block appears twice.

Each month's results are in reports/, as Markdown (YYYY-MM.md) and JSON (YYYY-MM.json).

Limitations

• Gross volume, not just payments. Transfers include exchange trading, routing through other contracts and issuer treasury movements, as well as payments.
• Failure rates cover direct calls only. Failed transactions that would have moved stablecoins through another contract cannot be attributed to a token.
• Two address formats. Transfers store addresses as 32-byte words; transactions store plain 20-byte addresses. Compare the last 40 characters (right(from_address, 40)) when matching addresses across tables. A plain equality test matches nothing, without an error.
• Rewritten days. On 61 days the source wrote or rewrote the day long after it happened (see load_manifest). Only the latest version is kept, so figures for those days may differ from what was available at the time.
• Amount precision. The source stores raw values as 64-bit floats. Amounts are accurate to well under a cent for transfers below about 9 billion tokens; above that, the last digits are rounded.
• One chain. Ethereum mainnet only. The same tokens on other chains are not included.
• Experimental source. AWS labels the upstream dataset experimental. The checks above passed, but report any gaps you find.
• Pseudonymous addresses. Do not use this data to try to identify individuals.

Source and licence

Derived from the AWS Public Blockchain Data Ethereum tables (s3://aws-public-blockchain/v1.0/eth/), published under MIT-0. This dataset is released under the MIT licence.

Pipeline: DuckDB on GitHub Actions reads the source Parquet, filters to the three tokens, runs the checks and uploads each month here. Code and run history: github.com/Andreas142/twinfault.