BitqueryBitqueryData Store
Arbitrum logoArbitrumTransfers

Arbitrum Transfers

Every native ETH and token transfer on Arbitrum since the Nitro upgrade in August 2022, one row per transfer, valued in USD where a price exists.

Coverage
Aug 31, 2022→ Oct 14, 2026 · yesterday
Rows
≈4.9Brows · estimate
Size
≈570 GBParquet · estimate
Table
1transfers
Columns
24typed
Refresh: dailyCoverage ends yesterday, UTC

Overview

We decode Arbitrum transfers from the chain ourselves: token transfer events, plus native ETH including what contracts move in internal calls. Each row carries the token's name, symbol and exact decimals, and a USD value for ETH and the main stablecoins, taken from Ethereum's hourly series. About 4.9 billion rows, from the Nitro upgrade at block 22,207,820 on 31 August 2022 to yesterday.

Most buyers start with flow for one token: filter Transfer_Currency_SmartContract to its contract, then group by sender and receiver. Filter Transfer_Currency_Native instead to see ETH moving on its own. Amounts are decimal strings, so cast with care, and join on contract addresses because symbols repeat.

Use cases

  • Token flow analysis for any contract on Arbitrum
  • Token balance history for any address, rebuilt from its transfers
  • Exchange deposit and withdrawal attribution
  • Native ETH movement separated from token movement

Table

24 columns · free sample for the table

transfers

24 columns

One row per native ETH or token transfer on Arbitrum, with sender, receiver, token metadata and a USD value where a price exists.

arbitrum/transfers<start_block>_<end_block>.parquet50 blocks per file, sorted ascending
Browse columns Sample fileSample updated Sep 25, 2026

Schema reference

copies a column name
24 columns
ColumnTypeDescription
Block3
Block_DateDateUTC date of the block
Block_NumberUInt64Block height
Block_TimeDateTimeBlock timestamp, UTC
Fee1
Fee_SenderFeeStringNetwork fee the sender paid for the whole transaction, in ETH, as a decimal string. It repeats on every row of the transaction, so count it once per transaction
Transaction3
Transaction_HashStringHash of the transaction this row settled in, 0x-prefixed; the join key to transactions and logs
Transaction_IndexUInt64Position of the transaction within the block
Transaction_TypeUInt32EIP-2718 transaction type: 0 legacy, 1 access list, 2 EIP-1559, 4 EIP-7702, plus Arbitrum's system types 100 to 106
TransactionStatus1
TransactionStatus_SuccessStringWhether the transaction succeeded; the string true or false. Failed transactions are kept
Transfer16
Transfer_AmountStringAmount moved, decimal adjusted, as a decimal string with exactly as many places as the token has decimals. Multiply by 10 to the power of the decimals for the raw on-chain integer
Transfer_AmountInUSDFloat64Amount valued in USD at the hourly price for the block's hour; 0 when the amount is 0 or the token has no price
Transfer_Currency_DecimalsInt32Decimals of the transferred currency, as its contract reports them
Transfer_Currency_DelegatedToStringImplementation address for proxy tokens; the string 0x when there is none
Transfer_Currency_FungibleStringWhether the currency is fungible; the string true or false, and false for NFTs
Transfer_Currency_NameStringName reported by the contract; lookalike tokens copy real names
Transfer_Currency_NativeStringtrue for native ETH, false for tokens. Filter on this to separate base-asset flow from token flow
Transfer_Currency_ProtocolNameStringToken standard, for example erc20 or erc721; empty for native ETH
Transfer_Currency_SmartContractStringContract of the transferred token, 0x-prefixed; the string 0x for native ETH
Transfer_Currency_SymbolStringSymbol reported by the contract; repeats across tokens, so join on the contract address
Transfer_IdStringToken id for NFT transfers; the string 0 for fungible transfers
Transfer_IndexUInt32Position within the transaction. Several rows in one transaction can share it
Transfer_SenderStringSending address, 0x-prefixed
Transfer_ReceiverStringReceiving address, 0x-prefixed
Transfer_TypeStringtoken for token transfers, transaction for a transaction's own value, call for ETH moved by an internal call
Transfer_URIStringMetadata URI for NFT transfers; empty otherwise
Sample file

Ask an AI about this data

Send this dataset’s full schema to an assistant and ask it anything. It reads the plain-text brief first, so the answer comes from the real column list rather than a guess.

Start with

Opens a new chat with the question filled in. Nothing about you is sent to Bitquery, and the assistant sees only the public brief.

Delivery

Parquet files in a Requester Pays S3 bucket or a Cloudflare R2 bucket, chosen at checkout. On S3 you download with your own AWS account and AWS bills the transfer; on R2 you download with a read-only API key and pay no egress. Layout:

# transfers: 50 blocks per file, sorted ascending
arbitrum/transfers<start_block>_<end_block>.parquet
  1. Download a free sampleNo email needed.
  2. Pay nowName, work email and licence check.
  3. Pay the invoiceBy card or bank transfer.
  4. Download from S3 or R2The team prepares the export and emails the bucket path, plus a read-only API key for R2 orders.

Time windows

Every window includes 24 columns. Only the time range changes.

30 days
Latest month
Sep 14, 2026 → Oct 14, 2026
$200
Pay now
365 days
Last 12 months
Oct 14, 2025 → Oct 14, 2026
$1,200
Pay now
730 days
Last 24 months
Oct 14, 2024 → Oct 14, 2026
$2,400
Pay now
1,505 days
Full history
Aug 31, 2022 → Oct 14, 2026
$6,000
Pay now
In every window
  • The transfers table, 24 columns
  • Parquet files in the layout under Delivery
  • S3 or R2 download, chosen at checkout
  • Licensed under the Data License

FAQ

11 questions
What is in the Arbitrum Transfers dataset?

One Parquet table with 24 columns: every native ETH and token transfer on Arbitrum, one row each, with the amount, the token's details, the transaction it settled in and the fee. ETH moved by contracts in internal calls is included, and so are NFTs.

How big is it?

About 4.9 billion rows over 50 months, roughly 570 GB as Parquet, estimated from the sample files. The last 24 months hold about 3.0 billion rows and the last 12 months about 1.3 billion. Row counts come from the live table; exact figures arrive with the delivery manifest.

How far back does it go?

To the start of indexed history: from 31 August 2022, the Nitro upgrade, at block 22,207,820. The chain's earlier history, Arbitrum Classic, is not in our index. The Full window runs from there to yesterday.

What was left out, and why?

The export applies no filter of its own: spam tokens, lookalike tokens, zero-value rows and failed transactions all stay in, and the columns let you drop them. Arbitrum Classic, the history before the Nitro upgrade, is not in our index. The Nitro genesis carried every Classic balance across with no transfer, so balances rebuilt from these rows alone will not match for any address or token that existed before Nitro.

How are amounts valued in USD?

Arbitrum has no price history of its own, so ETH, WETH, USDC, the bridged USDC.e, USDT and DAI are valued on Ethereum's series: bridged ETH is ETH, and using the real series keeps a de-peg visible. Other tokens, including WBTC, LINK and ARB, carry 0. In the linked sample file 73% of rows are priced; across all three sample files it is about 80%. A value of 0 means either a $0 transfer or no price; the column cannot tell them apart.

How are these produced, and how were they checked?

Decoded from Arbitrum by our own indexer, which reads token transfer events and traces internal calls for ETH. Before release we read the sample back: 329 rows over blocks 508,435,000 to 508,435,049, every amount carrying exactly its token's decimals. The live table returns the same 329 rows for those blocks.

Where is the raw integer amount?

The amount column is decimal adjusted. Multiply it by 10 to the power of the token's decimals for the raw on-chain integer. We ship the adjusted value because decimals differ per token and the raw figure is wrong without them.

What should I watch out for?

Amounts are decimal strings, so casting to float loses precision on large values. Symbols and names repeat, and lookalike tokens copy them, so join on the contract address. Failed transactions are kept; filter TransactionStatus_Success for settled flow. Zero-value rows, 1.8% of the sample, move nothing, so drop them before counting activity. Transaction_Type includes Arbitrum's own system types, numbered 100 to 106, alongside the standard 0, 1, 2 and 4.

How do I get one token, or native coin only?

Filter Transfer_Currency_SmartContract to the token's contract, lower case with 0x. For native ETH alone, filter Transfer_Currency_Native to true; its contract column holds the string 0x.

How do I load it?

One line in DuckDB: SELECT * FROM read_parquet('transfers/*.parquet') LIMIT 10. Pandas works too: pandas.read_parquet(path). The sample file opens without credentials.

How current is it, and how is it delivered?

Refreshed daily with T+1 latency, so a purchase made today includes everything to yesterday. Delivered as Parquet named by block range, 50 blocks per file and sorted ascending, under a stable layout with a JSON manifest listing every file and its sha256. We prepare the files within 7 business days of purchase and email you the location. You choose at checkout where to collect them: a Requester Pays S3 bucket, downloaded with your own AWS account, or a Cloudflare R2 bucket with a read-only API key and no egress fees. Files stay available for 7 days from delivery. Enterprise orders can be delivered into your own S3, GCS or R2 bucket.