Asset Transfers provides structured transfer history for an account. You can build a custom query from EVM tables in SQL Explorer, run that query through the SQL API, request curated account history through Explorer API, or extract transfers from a Stream with your own filter.
The Explorer API's qn_getAssetTransfers method covers native, ERC-20, ERC-721, and ERC-1155 transfers, plus internal transfers of native value made by contract calls. It returns the sender, recipient, asset, amount, transaction, and block for each matching transfer. See the chain-specific method reference for the full parameter and response schema.
SQL Explorer and Explorer API use the same underlying indexed data through different interfaces. In SQL Explorer, query the EVM tables for the transfer data you need. Explorer API provides qn_getAssetTransfers, an optimized JSON-RPC method that assembles a curated response. With Streams, write a filter over block, receipt, and trace data to extract transfers.
Network and access coverage
| Mainnet | SQL Explorer | SQL API | Explorer API |
|---|---|---|---|
| Ethereum | ✓ | ✓ | ✓ |
| BNB Smart Chain | ✓ | ✓ | ✓ |
| Arc | ✓ | ✓ | ✓ |
| Robinhood Chain | ✓ | ✓ | ✓ |
| Elysium | ✓ | ✓ | ✓ |
| Base | ✓ | ✓ | ✓ |
| Arbitrum One | ✓ | ✓ | ✓ |
EVM indexed data extends back to each supported network's genesis block. The SQL Explorer and SQL API networks above match the EVM query catalog. Explorer API method references are listed in its section below; the Base and Arbitrum One references are pending. Streams requires a custom filter and its supported networks and composite datasets should be checked separately in Streams supported chains and EVM data sources.
Choose an access method
- SQL Explorer: Build a custom transfer query from the available EVM tables in the dashboard.
- SQL API: Run any SQL Explorer query programmatically over REST.
- Explorer API: Request curated account transfer history through
qn_getAssetTransferson a chain endpoint. - Streams: Deliver transfers extracted from block, receipt, and trace data by a custom filter.
The worked examples below are intentionally scoped: the SQL example retrieves native transfers, and the Streams filter selects receipts containing ERC-20 events. qn_getAssetTransfers is the ready-made method covering all transfer types listed above.
- SQL Explorer
- SQL API
- Explorer API
- Streams
SQL Explorer
This example finds the 25 largest Ethereum native-currency transfers in the latest 1,000 blocks, including internal (trace-level) native transfers. Use the EVM token and log tables for ERC-20 or NFT transfers.
- Sign in to the Quicknode Dashboard and open SQL Explorer. Your account needs access to the EVM tables.
- Open Tables and inspect
evm_native_transfers,evm_blocks, andevm_native_currenciesin the EVM schema. These tables provide the fields used in this example. - Select the pre-built Largest native transfers query from EVM Queries, or paste the same query below into the SQL editor. It filters on
ethereum-mainnetand a recent block range to limit the data scanned. - Select Run. In Results, check the transaction hash, sender, recipient, amount, and
is_internalvalue. The query orders by amount and returns the largest transfers in the selected range. For a wallet's full history, build a query filtered by account address. - Edit the query for your use case, then Save it or select API to generate a programmatic request.
WITH
(SELECT max(number) FROM evm_blocks WHERE network = 'ethereum-mainnet') AS head,
(SELECT symbol FROM evm_native_currencies FINAL WHERE network = 'ethereum-mainnet') AS native_symbol,
(SELECT decimals FROM evm_native_currencies FINAL WHERE network = 'ethereum-mainnet') AS native_decimals
SELECT
block_number,
block_datetime,
evm_hash_pretty(transaction_hash) AS transaction_hash,
evm_address_pretty(from_address) AS sender,
evm_address_pretty(to_address) AS recipient,
amount / exp10(native_decimals) AS amount_native,
native_symbol,
is_internal,
call_type
FROM evm_native_transfers FINAL
WHERE network = 'ethereum-mainnet' AND block_number > head - 1000
ORDER BY amount DESC
LIMIT 25
To run this query on another supported chain, replace every ethereum-mainnet value in it with the corresponding SQL network value:
| Chain | SQL network value |
|---|---|
| Ethereum | ethereum-mainnet |
| BNB Smart Chain | bsc |
| Base | base-mainnet |
| Arbitrum One | arbitrum-mainnet |
| Arc | arc-mainnet |
| Robinhood Chain | robinhood-mainnet |
| Elysium | elysium-mainnet |
The EVM query catalog also includes Recent ERC-20 transfers and Token transfer history examples. The latter follows one token. For NFT transfers or an account-wide history, inspect the EVM schema and build the query you need. See Getting Started with SQL Explorer for the dashboard workflow.
SQL API (REST)
The SQL API executes the same query you run in SQL Explorer over REST. This example runs the native-transfer query above with the EVM cluster ID evm-mainnet.
- In the dashboard, open your profile menu and select API Keys. Create an API key with SQL Explorer access, or use an existing key that has it enabled.
- Run the query in the SQL Explorer tab on this page first. Select API in SQL Explorer to see the generated request and confirm the query and
clusterIdfor your account. - Copy the generated cURL request for Largest native transfers from the EVM query catalog. Replace
YOUR_API_KEYand run it. The request below is the catalog's generated request for Ethereum; it sends the query andclusterIdin the JSON body. - Check
datafor the rows andstatisticsfor execution metrics. If you edit the SQL in the dashboard, copy its updated API request so both interfaces run the same query.
curl -X POST 'https://api.quicknode.com/sql/rest/v1/query' \
-H 'Content-Type: application/json' \
-H 'x-api-key: YOUR_API_KEY' \
--data-binary @- <<'JSON'
{
"query": "WITH\n (SELECT max(number) FROM evm_blocks WHERE network = 'ethereum-mainnet') AS head,\n (SELECT symbol FROM evm_native_currencies FINAL WHERE network = 'ethereum-mainnet') AS native_symbol,\n (SELECT decimals FROM evm_native_currencies FINAL WHERE network = 'ethereum-mainnet') AS native_decimals\nSELECT\n block_number,\n block_datetime,\n evm_hash_pretty(transaction_hash) AS transaction_hash,\n evm_address_pretty(from_address) AS sender,\n evm_address_pretty(to_address) AS recipient,\n amount / exp10(native_decimals) AS amount_native,\n native_symbol,\n is_internal,\n call_type\nFROM evm_native_transfers FINAL\nWHERE network = 'ethereum-mainnet' AND block_number > head - 1000\nORDER BY amount DESC\nLIMIT 25",
"clusterId": "evm-mainnet"
}
JSON
To run the SQL API request for another supported chain, replace every ethereum-mainnet value in the query with its value in the SQL Explorer table above. Keep the clusterId returned for your account.
The SQL Explorer REST API reference documents authentication, schema discovery, request fields, and responses. Confirm that your account has access to the EVM tables and cluster before running this example.
The SQL API also provides GET /sql/rest/v1/schema/{clusterId} for discovering the tables and columns available to your account. Its documented result limit is 1,000 rows per request; use SQL LIMIT and OFFSET for larger result sets. SQL API requests share the plan-based Platform API rate-limit bucket with other Platform APIs. See the REST API reference for response fields such as data, rows, and statistics.
Explorer API (JSON-RPC)
Explorer API is the curated, optimized JSON-RPC path to the same underlying indexed data used by SQL Explorer. It is currently in beta and requires a paid plan. Contract and token metadata coverage is still expanding. Check access to the method before relying on it in an application.
- Create or select a Quicknode endpoint for a supported chain listed below. Confirm that Explorer API access is available for your account and endpoint.
- Copy the endpoint URL and authentication token from the dashboard.
- Call
qn_getAssetTransferswith anaccountsarray. Setdirectiontoanyfor both incoming and outgoing transfers, and uselimitfor the page size. - Read
result.data. Ifresult.page.cursoris non-null, send another request with that cursor and the same query fields to retrieve the next page.
Use qn_getAssetTransfers on a Quicknode endpoint for a supported chain. This complete Ethereum example requests the 10 most recent transfers involving an address. Replace the endpoint and address with your own values. The token is sent in an x-token header, following the existing wallet transfer history guide.
export QUICKNODE_ENDPOINT="https://<endpoint-name>.ethereum-mainnet.quiknode.pro/"
printf 'Quicknode auth token: '
read -rs QUICKNODE_TOKEN
printf '\n'
export QUICKNODE_TOKEN
export WALLET_ADDRESS=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045
curl "$QUICKNODE_ENDPOINT" \
-H 'Content-Type: application/json' \
-H "x-token: $QUICKNODE_TOKEN" \
-d @- <<EOF
{
"jsonrpc": "2.0",
"id": 1,
"method": "qn_getAssetTransfers",
"params": {
"accounts": ["$WALLET_ADDRESS"],
"direction": "any",
"limit": 10
}
}
EOF
The response contains a result.data array and a result.page.cursor. Pass a non-null cursor with the same query fields to request the next page. An empty data array means there were no matching transfers. Token metadata can be incomplete: asset.symbol may be absent, and asset.decimals and amount.value may be null. Use amount.raw for the exact base-unit amount.
Limit transfers to a block range
Use filter.blocks when you need a defined block window instead of the latest account activity. After setting the endpoint, token, and wallet variables above, run this request using the block range from the published Ethereum guide:
curl "$QUICKNODE_ENDPOINT" \
-H 'Content-Type: application/json' \
-H "x-token: $QUICKNODE_TOKEN" \
-d @- <<EOF
{
"jsonrpc": "2.0",
"id": 1,
"method": "qn_getAssetTransfers",
"params": {
"accounts": ["$WALLET_ADDRESS"],
"filter": { "blocks": { "gte": 24000000, "lte": 24100000 } },
"limit": 10
}
}
EOF
gte includes the starting block and lte includes the ending block. A block filter must have one lower bound (gt or gte); an upper bound (lt or lte) is optional. Use block heights from the network selected by your endpoint. If the response has a cursor, keep the same block bounds when requesting the next page.
Request options
| Field | Required | Purpose |
|---|---|---|
| accounts | Yes | Account addresses to query on the endpoint network. |
| direction | No | any for incoming and outgoing, in for incoming only, or out for outgoing only. |
| filter.blocks | No | Block-height window with one lower bound (gt or gte) and an optional upper bound (lt or lte). |
| limit | No | Number of transfers to request per page. |
| cursor | No | Cursor from result.page.cursor for the next page; omit for the first request. |
Reading a transfer
Each record in result.data identifies the network and transfer, its direction relative to the queried account, the sender and recipient, the asset and amount, and the containing transaction and block. These are the fields to look for in the method response:
| Response field | Meaning |
|---|---|
| network, transferId, type | Network, transfer identifier, and transfer type. |
| direction, from, to | Direction relative to the queried account and the two addresses. |
| asset | Asset identifier, standard, type, and available token metadata. |
| amount.raw, amount.value | Base-unit amount as a string and decimal-formatted amount when available. |
| tx.hash | Hash of the transaction containing the transfer. |
| block.height, block.hash, block.timestamp | Block number, hash, and ISO 8601 timestamp. |
| position | Transaction, log, or trace position when provided for that transfer type. |
Supported chains
The Explorer API qn_getAssetTransfers method is supported on these chains. The example above uses Ethereum; use an endpoint for the chain you want to query.
| Chain | Method reference |
|---|---|
| Ethereum | qn_getAssetTransfers |
| BNB Smart Chain | qn_getAssetTransfers |
| Arc | qn_getAssetTransfers |
| Robinhood Chain | qn_getAssetTransfers |
| Elysium | qn_getAssetTransfers |
| Base | Method reference pending |
| Arbitrum One | Method reference pending |
Streams
To receive transfers with Streams, select a blockchain data source and write a filter that extracts the events or movements you need. The worked example below delivers receipts containing ERC-20 Transfer events. Native, NFT, and internal transfers require filters suited to those movements.
- Open the Streams dashboard and select New Stream. Choose Ethereum Mainnet and a start block. Use the latest block for new activity or an earlier block to backfill. Check supported chains before using another network.
- Select Block with Receipts. The published ERC-20 receipt filter below uses this dataset's
receiptsarray. For native or internal transfers, choose the appropriate block and trace data and write a filter for those movements. - Select Fetch payload to inspect a sample. Open Customize your payload, choose JavaScript, and paste the filter below. Select Run test and inspect
totalReceipts,filteredCount, andreceiptsbefore saving the filter. - For this example, choose a webhook destination, enter its URL, and select Check Connection. Create the Stream and inspect deliveries and logs in the dashboard. The Streams quickstart shows this setup with screenshots.
You can also deliver the filtered data to Amazon S3, Azure Blob Storage, Kafka, or PostgreSQL. See Streams destinations for setup details.
function main(stream) {
const TRANSFER_TOPIC =
'0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
let totalReceipts = 0
const transferReceipts = []
for (const entry of stream.data) {
const receipts = entry.receipts || []
totalReceipts += receipts.length
for (const receipt of receipts) {
const hasTransfer = receipt.logs.some(
log => log.topics[0] === TRANSFER_TOPIC && log.topics.length === 3
)
if (hasTransfer) {
transferReceipts.push(receipt)
}
}
}
return {
totalReceipts,
filteredCount: transferReceipts.length,
receipts: transferReceipts,
}
}
This published filter returns receipt records containing ERC-20 Transfer events. For a broader feed, use the EVM data-source reference and Streams filter examples to choose and test a filter for each transfer type.