Etherscan APIetherscan.io ↗
Access Ethereum address balances, transactions, token transfers, NFT transfers, gas prices, and block data from Etherscan via a single REST API.
What is the Etherscan API?
This API exposes 10 endpoints covering Etherscan's Ethereum blockchain explorer data, including address overviews, transaction histories, ERC-20 and NFT transfers, block details, and live gas prices. The get_address_transactions endpoint returns paginated normal transactions with hash, method, block, from/to addresses, value, and fee data. It also includes a search endpoint that resolves Ethereum addresses, ENS names, transaction hashes, and block numbers to their canonical Etherscan result.
curl -X GET 'https://api.parse.bot/scraper/086c5613-58b6-4812-8aea-da40196b8e5d/get_address_overview?address=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace etherscan-io-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Etherscan SDK — bounded, re-runnable; every call capped."""
from parse_apis.etherscan_api import Etherscan, AddressNotFound
client = Etherscan()
# Fetch an address overview by its 0x address.
addr = client.addresses.get(address="0x1234567890123456789012345678901234567890")
print(addr.eth_balance, addr.ens_name, addr.labels)
# Browse the address's normal transactions (limit caps total items).
for tx in addr.transactions(limit=3):
print(tx.Transaction_Hash, tx.Method)
# Browse the address's NFT transfers.
for nft in addr.nft_transfers(limit=3):
print(nft.tx_hash, nft.nft_name, nft.token_id)
# Fetch gas prices — no arguments needed.
gas = client.gasprices.current()
print(gas.low, gas.avg, gas.high)
# Fetch a block by number.
block = client.blocks.get(block_number="17000000")
print(block.block_number, block.Timestamp, block.Gas_Used)
# Typed error handling: attempt to look up a nonexistent address.
try:
client.addresses.get(address="0x0000000000000000000000000000000000000000")
except AddressNotFound as exc:
print(f"Address not found: {exc}")
# Search for an ENS name.
result = client.searchresults.lookup(query="user.eth")
print(result.type, result.address)
print("exercised: addresses.get / transactions / nft_transfers / gasprices.current / blocks.get / searchresults.lookup")
Returns summary info for an Ethereum address: ETH balance, ETH value in USD, token holdings, labels, and ENS name. The address must be a valid 0x-prefixed Ethereum address or ENS-resolved address.
| Param | Type | Description |
|---|---|---|
| addressrequired | string | Ethereum address (0x-prefixed, 42 characters) |
{
"type": "object",
"fields": {
"labels": "array of strings - public name tags/labels",
"address": "string - the queried Ethereum address",
"ens_name": "string - ENS domain name if registered",
"eth_value": "string - ETH value in USD",
"eth_balance": "string - ETH balance with unit",
"token_holdings_count": "string - number of tokens held",
"token_holdings_summary": "string - summary of token holdings",
"token_holdings_value_usd": "string - total token holdings value in USD"
},
"sample": {
"data": {
"labels": [
"Gitcoin Grantee"
],
"address": "0xREDACTED_SECRET",
"ens_name": "vitalik.eth",
"eth_value": "$9,339.37 (@ $1,641.70/ETH)",
"eth_balance": "5.688840446715981478 ETH",
"token_holdings_count": ">401",
"token_holdings_summary": ">$95,810.00 (>401 Tokens)",
"token_holdings_value_usd": "95,810.00"
},
"status": "success"
}
}About the Etherscan API
Address and Transaction Data
The get_address_overview endpoint accepts any Ethereum address (0x...) and returns the ETH balance, USD value, ENS name if registered, public labels or name tags, and a summary of token holdings including total USD value and count. For transaction history, get_address_transactions and get_address_internal_transactions both support pagination via the page parameter and return structured records with block number, parent transaction hash, from/to addresses, method signature, and transferred value. Internal transactions are separated from normal ones to reflect how Etherscan categorizes contract-initiated transfers.
Token and NFT Transfers
get_address_erc20_token_transfers returns paginated ERC-20 transfer events for an address, each record including transaction hash, method, block, from/to fields, transfer amount, and token name. get_address_nft_transfers covers ERC-721 and ERC-1155 events and includes token_id, nft_name, type, and a total_records count in the response, making it straightforward to determine the full scope of an address's NFT activity without fetching every page.
Gas, Price, and Block Data
get_gas_tracker returns three gas price tiers — low, average, and high — each in gwei with a detail string breaking down the base fee and priority fee components. get_eth_price_and_stats returns the current ETH price in USD and median gas price as shown on the Etherscan homepage. get_block_details accepts a block number and returns the fee recipient (validator), gas used and limit, block reward, and timestamp.
Search and Resolution
The search endpoint accepts a free-form query and resolves it to a typed result: address, transaction, block, or search_results. For ENS names, it returns the resolved Ethereum address. The url field in the response points to the final resolved Etherscan page, and the type field lets consuming code branch without string-matching the query format.
The Etherscan API is a managed, monitored endpoint for etherscan.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when etherscan.io changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official etherscan.io API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Monitor an Ethereum wallet's ETH balance and token holdings value in USD using
get_address_overview - Build a transaction history feed for a DeFi dashboard using
get_address_transactionswith pagination - Track ERC-20 inflows and outflows for a treasury address using
get_address_erc20_token_transfers - Audit an address's full NFT transfer history, including token IDs and collection names, via
get_address_nft_transfers - Display real-time gas price tiers (low/avg/high) with base fee breakdowns using
get_gas_tracker - Resolve an ENS name to its Ethereum address programmatically using the
searchendpoint - Retrieve block-level reward and validator data for staking analytics using
get_block_details
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Etherscan have an official developer API?+
What does `get_address_nft_transfers` return and how does it differ from `get_address_erc20_token_transfers`?+
get_address_nft_transfers covers ERC-721 and ERC-1155 events and includes token_id, nft_name, type (indicating the token standard), and a top-level total_records count. get_address_erc20_token_transfers covers fungible token transfers and returns amount and token name but no token ID, since ERC-20 tokens are not individually identified. Both endpoints support pagination via the page parameter.Does the API return contract source code, ABI, or verified contract data?+
How does pagination work across the transaction and transfer endpoints?+
get_address_transactions, get_address_internal_transactions, get_address_erc20_token_transfers, and get_address_nft_transfers endpoints all accept an optional integer page parameter. The response includes a page field confirming the current page. Only get_address_nft_transfers currently returns a total_records count; the other endpoints do not expose a total count or page count in the response fields.