Home / Solutions / Wallets & Payments
Wallets & Payments

Wallet transaction history for any address, on any chain

Query any address and get its history: token transfers, native and internal value, NFT movements, and contract calls, across 225+ networks through one query shape. Balances and portfolios are computed from that history, not read from a per-chain API.

225+ Networks
Any address Address-keyed
Logs + traces Complete history
ERC-20/721/1155 Token standards
Capabilities

Built for Wallets & Payments at scale

>

Address-keyed history

Filter logs, traces, and transactions by address in one query shape. Token transfers, native and internal value, NFT movements, and contract calls for any address, streamed with cursor pagination even for addresses with millions of transfers.

$

Multi-standard token data

ERC-20 transfers, ERC-721 ownership changes, and ERC-1155 batch transfers, decoded with token metadata. The same Transfer history is what you fold into per-token balances, so you control the reconstruction instead of trusting a cached snapshot.

+

One query shape, every chain

The same address-filtered query runs against Ethereum, Base, Arbitrum, Solana, and the rest. Point it at each dataset and merge, so a unified multi-chain feed is one integration instead of a separate client per network.

!

Transfer streaming for alerts

Stream Transfer, Approval, and ApprovalForAll events for monitored addresses as they confirm onchain. Build payment notifications, approval-revocation alerts, and activity feeds without managing WebSocket connections.

Address-keyed

One query, keyed by address, not by block

A blockchain stores data by block and transaction; a wallet needs it by address. That re-keying is the whole problem, because a node's JSON-RPC has no eth_getTransactionsByAddress. The Portal indexes the chain ahead of time and lets you filter logs, traces, and transactions by address in one request shape.

We asked the Portal for vitalik.eth's last seven days (blocks 25,328,971 to 25,379,204). One address-keyed query returned 30 activity rows across transactions, token transfers, and NFT movements. The asset flow it summed:

AssetNet in windowKind
  • ETH+0.0001native
  • USDC+5.541929token
  • MOODENG+17,776token (airdrop)
  • WARS+10token (airdrop)

A few real transfers (USDC, ETH) buried in airdrop spam (MOODENG, WARS, plus six unnamed tokens). Separating real holdings from spam is the wallet-history problem, and it starts with having every transfer in one place. The largest single inbound was 0xd6f1…d48f at block 25,373,139.

The primitive underneath is one log filter. Transfer puts the recipient in topic2; query it across every ERC-20 and ERC-721 token (which share the Transfer signature), with no contract filter, over any block window:

incoming ERC-20/721 transfers
POST https://portal.sqd.dev/datasets/ethereum-mainnet/stream
{
"type": "evm",
"fromBlock": 25328971,
"toBlock": 25379204,
"logs": [{
"topic0": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"],
"topic2": ["0x000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"]
}],
"fields": {
"block": { "number": true, "timestamp": true },
"log": { "address": true, "topics": true, "data": true, "transactionHash": true }
}
}

Swap topic2 for topic1 to get outgoing transfers. The log's address is the token contract; the amount is in data. Point the same body at base-mainnet or arbitrum-one for other chains.

Why it's harder elsewhere

A log-only feed silently drops value

The hardest part of a wallet history is the value that logs do not record. When a contract forwards ETH to an address mid-execution, a withdrawal, a disbursement, a batched payout, nothing appears in the transaction list or the event logs. It only exists in the execution trace. A feed built on logs alone returns a history that omits it, which is a correctness bug in a balance, not a gap in coverage. The Portal exposes traces filtered by callTo and callFrom in the same request shape as the logs query above:

native + internal value, from traces
{
"type": "evm",
"fromBlock": 25328971,
"toBlock": 25379204,
"traces": [
{ "type": ["call"], "callTo": ["0xd8da6bf26964af9d7eed9e03e53415d37aa96045"], "transaction": true },
{ "type": ["call"], "callFrom": ["0xd8da6bf26964af9d7eed9e03e53415d37aa96045"], "transaction": true }
],
"fields": {
"block": { "number": true, "timestamp": true },
"transaction": { "hash": true },
"trace": { "type": true, "transactionIndex": true, "callFrom": true, "callTo": true, "callValue": true }
}
}

Balances are derived, not returned

The Portal serves transfers, not balances. A balance is the sum of transfers in minus out per token, and a historical balance is that sum truncated at a block. You fold the transfer history into balances in a Squid SDK indexer, which keeps the reconstruction under your control.

The full three-query walk

Logs, traces, and transactions filtered by address, unioned by transaction hash, are the complete timeline. The wallet history guide shows each query and how balances fall out of the indexed result.

Data Coverage

Everything a wallet feed reads from, in one API

Stop stitching together separate providers for transactions, token transfers, NFTs, approvals, and internal value. The Portal serves the full data surface a wallet renders from.

Native transfers ETH, SOL, MATIC, every native currency transfer, including the internal ones that only appear in traces
ERC-20 transfers Full transfer history with decoded token names, symbols, and decimals for display
NFT movements ERC-721 and ERC-1155 transfers, including batch operations and token IDs
Token approvals Approval and ApprovalForAll events, the data behind approval revocation UIs
Contract interactions Decoded function calls with parameter names and types, not raw calldata
Internal transactions Nested calls that move funds through contracts, invisible to log-only indexers
Use Cases

What teams build with SQD

Wallet activity feeds with decoded token transfers
Multi-chain portfolio views computed from transfer history
Payment verification and receipt generation
Token approval management and revocation UIs
Address activity monitoring for custody and treasury
Internal-transfer-aware accounting and reconciliation

Frequently asked questions

How do I get a wallet's full transaction history?
A complete history is the union of three address-filtered queries against the Portal: token transfers (ERC-20 and ERC-721 Transfer logs with the address in topic1 or topic2; ERC-1155 uses separate TransferSingle and TransferBatch events with their own filters), native and internal value (traces filtered by callFrom and callTo, which is where contract-forwarded ETH lives), and top-level transactions where the address is the sender or recipient. Union them by transaction hash for the full timeline. A node's JSON-RPC has no address index, so it cannot answer this directly. The wallet history guide walks through each query.
Does the Portal return token balances directly?
No. The Portal serves transfer history, not reconstructed balances. A token balance is the sum of every transfer in minus every transfer out for an address and token, computed from the indexed history; a historical balance is the same sum truncated at a block. Reading balanceOf from contract state is a useful reconciliation check, but doing it for every token an address might hold is expensive, so production wallets compute balances from transfers with a Squid SDK indexer.
Can one query return history across multiple chains?
The same address-filtered query shape runs against every dataset (ethereum-mainnet, base-mainnet, arbitrum-one, and the rest), so a multi-chain feed is the same queries pointed at several chains and merged, not a separate integration per network. CoolWallet, a cold hardware wallet with 300,000+ users, uses this pattern across 35+ chains in production.
How are internal transfers and contract-forwarded value handled?
They come from execution traces, not logs. When a contract forwards ETH to an address mid-execution (a withdrawal, a disbursement, a batched payout), nothing appears in the transaction list or event logs, only in the traces data type filtered by callTo. A log-only feed silently omits this value, which is a correctness bug in a wallet balance. The Portal exposes traces alongside logs and transactions in the same request shape.
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.