Transfers

One row per fungible token movement: a transfer, a mint or a burn, on every chain we decode. amount_raw is the amount in the token’s smallest unit, so divide it by 10^decimals from dimensions.tokens to read whole tokens.

Columns

Column	Type	Description
`partition_key`	`TIMESTAMP`	The month the row belongs to, as its first instant. The table is partitioned on it, so bound it alongside `block_timestamp`.
`block_timestamp`	`TIMESTAMP`	Time of the block containing the movement.
`block_number`	`INT64`	Block height, or the slot on Solana.
`transaction_hash`	`STRING`	Transaction the movement belongs to. Null on `hydradx`, where a transfer can be emitted by a block hook rather than by a transaction.
`transaction_index`	`INT64`	Position of the transaction in its block. Solana only: a decoded Transfer event on the log-shaped chains is the log, and the transaction around it lives in that chain’s own transaction table.
`outer_event_index`	`INT64`	Enclosing instruction position on Solana. A log has one position and an instruction has two, so this is null on the log-shaped chains, and null on a top-level Solana instruction, which has nothing enclosing it.
`event_index`	`INT64`	Position within the transaction: the log index, or the instruction index on Solana.
`chain_id`	`STRING`	Chain the movement happened on.
`token_type`	`STRING`	Token standard: `erc20`, `spl` or `trc20`.
`token_id`	`STRING`	Join key to `dimensions.tokens` and the asset tables, which are laid out on it: `{token_address}-{chain_id}`.
`token_address`	`STRING`	The token, and the leading cluster key: filter on this with `chain_id` to read one token, and on this alone to read the address across every chain in one pass. `erc20` addresses are stored lowercase and every other standard as the chain writes it, `spl` and `trc20` being base58. Null on the Solana transfers whose token account the upstream decode could not resolve, which leaves `token_id` null with it.
`event_type`	`STRING`	`transfer`, `mint` or `burn`. Solana’s token program names it; on the log-shaped chains it is read from the EIP-20 zero address, so a burn sent to some other dead address reads as `transfer`.
`from_address`	`STRING`	Account debited: a wallet on the log-shaped chains, an SPL token account on Solana. Null on a mint.
`to_address`	`STRING`	Account credited: a wallet on the log-shaped chains, an SPL token account on Solana. Null on a burn.
`to_owner`	`STRING`	Holder behind `to_address`, on Solana transfers, where one wallet can own several token accounts. On the log-shaped chains `to_address` is already the holder. Null on exactly the rows where `token_address` is null, since one upstream decode resolves a token account to both its mint and its owner, and null on Solana mints and burns, whose upstream tables hold no owner column.
`authority_address`	`STRING`	Account that authorised the instruction. Solana only.
`transaction_signer`	`STRING`	Signer of the enclosing transaction. Solana only.
`executing_account`	`STRING`	Program that executed the instruction. Solana only.
`amount_raw`	`STRING`	Amount in the token’s smallest unit, as a decimal string, because a uint256 exceeds every BigQuery numeric type. Divide by `10^decimals`.
`surrogate_key`	`BYTES`	Row identity: a 128-bit hash of the columns that define the grain, stable across rebuilds. Compare it with `from_hex`.

Sample queries

This table is large and split by month. Bound partition_key and filter chain_id on every query, or you read the whole table and the whole table is billed to you.

token_address and chain_id are the cluster keys and partition_key names the month, so the three together read only the blocks this token occupies. Cast amount_raw to BIGNUMERIC and divide by 10^decimals from dimensions.tokens for whole tokens.

select
    transfers.block_timestamp,
    transfers.transaction_hash,
    transfers.from_address,
    transfers.to_address,
    cast(transfers.amount_raw as bignumeric) / pow(10, tokens.decimals) as amount
from `facts_tokens.transfers` as transfers
join `dimensions.tokens` as tokens
    using (token_id)
where transfers.token_address = '0xdac17f958d2ee523a2206206994597c13d831ec7'
  and transfers.chain_id = 'ethereum'
  and transfers.partition_key >= timestamp('2026-08-01')
  and transfers.partition_key < timestamp('2026-09-01')
  and transfers.block_timestamp >= timestamp('2026-08-01')
  and transfers.block_timestamp < timestamp('2026-08-02')
limit 100

Leaving chain_id out reads the address on every chain it is deployed at in one pass, which the clustering is built for. partition_key still bounds the months the query reads.

select
    transfers.chain_id,
    count(*) as movements,
    count(distinct transfers.from_address) as senders
from `facts_tokens.transfers` as transfers
where transfers.token_address = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'
  and transfers.partition_key >= timestamp('2026-08-01')
  and transfers.partition_key < timestamp('2026-09-01')
  and transfers.block_timestamp >= timestamp('2026-08-01')
  and transfers.block_timestamp < timestamp('2026-08-08')
group by transfers.chain_id
order by movements desc

amount_raw is a decimal string, so ordering on it directly sorts lexically. Order on the decimal-corrected amount instead, as here.

select
    transfers.block_timestamp,
    transfers.transaction_hash,
    transfers.from_address,
    transfers.to_address,
    cast(transfers.amount_raw as bignumeric) / pow(10, tokens.decimals) as amount
from `facts_tokens.transfers` as transfers
join `dimensions.tokens` as tokens
    using (token_id)
where transfers.token_address = '0xdac17f958d2ee523a2206206994597c13d831ec7'
  and transfers.chain_id = 'ethereum'
  and transfers.partition_key >= timestamp('2026-08-01')
  and transfers.partition_key < timestamp('2026-09-01')
  and transfers.block_timestamp >= timestamp('2026-08-01')
  and transfers.block_timestamp < timestamp('2026-08-08')
order by amount desc
limit 20

An SPL mint address is base58 and is matched as the chain writes it. from_address and to_address are token accounts here, to_owner is the wallet behind the credited one, and dimensions.accounts names the addresses somebody has attributed.

select
    transfers.block_timestamp,
    transfers.transaction_hash,
    transfers.from_address,
    transfers.to_address,
    transfers.to_owner,
    cast(transfers.amount_raw as bignumeric) / pow(10, tokens.decimals) as amount
from `facts_tokens.transfers` as transfers
join `dimensions.tokens` as tokens
    using (token_id)
where transfers.token_address = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
  and transfers.chain_id = 'solana'
  and transfers.partition_key >= timestamp('2026-08-01')
  and transfers.partition_key < timestamp('2026-09-01')
  and transfers.block_timestamp >= timestamp('2026-08-01')
  and transfers.block_timestamp < timestamp('2026-08-02')
limit 100

outer_event_index is null where a chain has one nesting level, so nulls first groups those rows together and event_index decides inside the group. The same ordering holds on every chain.

select
    transfers.block_timestamp,
    transfers.transaction_hash,
    transfers.outer_event_index,
    transfers.event_index,
    transfers.from_address,
    transfers.to_address,
    cast(transfers.amount_raw as bignumeric) / pow(10, tokens.decimals) as amount
from `facts_tokens.transfers` as transfers
join `dimensions.tokens` as tokens
    using (token_id)
where transfers.token_address = '0xdac17f958d2ee523a2206206994597c13d831ec7'
  and transfers.chain_id = 'ethereum'
  and transfers.partition_key >= timestamp('2026-08-01')
  and transfers.partition_key < timestamp('2026-09-01')
  and transfers.block_timestamp >= timestamp('2026-08-01')
  and transfers.block_timestamp < timestamp('2026-08-02')
order by transfers.block_number,
         transfers.outer_event_index nulls first,
         transfers.event_index
limit 100

A mint fills to_address and a burn fills from_address, so coalesce picks whichever side the row has. Supply read off these rows stays exact even for a rebasing token, whose holder balances accrue between movements.

select
    transfers.block_timestamp,
    transfers.event_type,
    transfers.transaction_hash,
    coalesce(transfers.to_address, transfers.from_address) as account,
    cast(transfers.amount_raw as bignumeric) / pow(10, tokens.decimals) as amount
from `facts_tokens.transfers` as transfers
join `dimensions.tokens` as tokens
    using (token_id)
where transfers.token_address = '2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo'
  and transfers.chain_id = 'solana'
  and transfers.event_type in ('mint', 'burn')
  and transfers.partition_key >= timestamp('2026-08-01')
  and transfers.partition_key < timestamp('2026-09-01')
  and transfers.block_timestamp >= timestamp('2026-08-01')
  and transfers.block_timestamp < timestamp('2026-08-08')
order by transfers.block_timestamp
limit 100

Splitting each movement into its credit and its debit and summing them replays a balance where a balance moves by movement alone. A rebasing token accrues between movements, and an SPL mint configured for confidential transfers moves value the instruction keeps private, so the balance functions inherit the same limit.

with legs as (
    select
        transfers.to_address as account_address,
        cast(transfers.amount_raw as bignumeric) / pow(10, tokens.decimals) as amount
    from `facts_tokens.transfers` as transfers
    join `dimensions.tokens` as tokens
        using (token_id)
    where transfers.token_address = '0xdac17f958d2ee523a2206206994597c13d831ec7'
      and transfers.chain_id = 'ethereum'
      and transfers.partition_key >= timestamp('2026-08-01')
      and transfers.partition_key < timestamp('2026-09-01')
      and transfers.block_timestamp >= timestamp('2026-08-01')
      and transfers.block_timestamp < timestamp('2026-08-08')

    union all

    select
        transfers.from_address,
        -cast(transfers.amount_raw as bignumeric) / pow(10, tokens.decimals)
    from `facts_tokens.transfers` as transfers
    join `dimensions.tokens` as tokens
        using (token_id)
    where transfers.token_address = '0xdac17f958d2ee523a2206206994597c13d831ec7'
      and transfers.chain_id = 'ethereum'
      and transfers.partition_key >= timestamp('2026-08-01')
      and transfers.partition_key < timestamp('2026-09-01')
      and transfers.block_timestamp >= timestamp('2026-08-01')
      and transfers.block_timestamp < timestamp('2026-08-08')
)

select
    account_address,
    sum(amount) as net_amount
from legs
where account_address is not null
group by account_address
order by net_amount desc
limit 20

Overview

Popular datasets

Market verticals

Chain ecosystems

Core entities

Columns

Sample queries

​Columns

​Sample queries

Columns

Sample queries