# Alchemy

> Read 100+ blockchains through Alchemy's APIs with one key: native and token balances, transactions with their fees, event logs and read-only contract calls on Ethereum, Base, Arbitrum, Polygon and every other EVM chain Alchemy serves; a wallet's full transfer history and its tokens across networks priced in USD; the NFTs a wallet holds, an NFT's metadata and owner, a collection's details and floor price; and current and historical token prices. Every action is read-only, so no private key is ever asked for. Setup is one field: create a free app at dashboard.alchemy.com and paste its API key.

App · Cryptocurrency · 20 actions. Web page: https://docs.lodol.com/docs/integrations/alchemy

## Actions

### Call contract (read-only)

Run a read-only call against a contract and get what it returned. Nothing is signed or sent and no gas is paid: this is how a view function such as balanceOf, totalSupply or ownerOf is read. The answer is ABI-encoded hex; a single number or address also comes back decoded.

**Inputs**

- Contract address (`to`, text, required): The contract to call.
- Call data (`data`, text, required): The ABI-encoded function call, as hex: the four-byte selector followed by the arguments. For balanceOf that is 0x70a08231 followed by the address padded to 32 bytes.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- From address (`from_address`, text): The address the call should appear to come from, for functions whose answer depends on the caller. Optional.
- Block (`block`, text): The block to read at: a block number, or 'latest', 'safe', 'finalized', 'earliest' or 'pending'. Leave blank for the latest block. Default: `latest`.

**Outputs**

- `block` (text): Block it was read at
- `data` (text): Call data sent
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `result` (text): What the contract returned, ABI-encoded hex
- `result_address` (text): The result read as an address, when it is one
- `result_integer` (text): The result read as one unsigned integer, as a decimal string, when it is 32 bytes or fewer
- `to` (text): Contract called

**Example output**

```json
{
  "block": "latest",
  "data": "0x70a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045",
  "network": "eth-mainnet",
  "result": "0x00000000000000000000000000000000000000000000000000000004a817c800",
  "result_address": null,
  "result_integer": "20000000000",
  "to": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
}
```

### Get block

Get a block by number, or the latest one, with its time, gas use, base fee and how many transactions it holds. The natural first step of a workflow that watches a chain: the block number it returns is what the block-ranged actions take.

**Inputs**

- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- Block (`block`, text): The block to read at: a block number, or 'latest', 'safe', 'finalized', 'earliest' or 'pending'. Leave blank for the latest block. Default: `latest`.
- Include transaction hashes (`include_transactions`, true/false): Also list the hash of every transaction in the block. A busy Ethereum block holds a couple of hundred, so they are left out unless asked for. Default: `false`.

**Outputs**

- `base_fee_per_gas_gwei` (number): Base fee per gas in gwei
- `base_fee_per_gas_wei` (text): Base fee per gas in wei, exact, as a string
- `block` (text): What was asked for: a tag, or the number in hex
- `block_hash` (text): Block hash
- `block_number` (number): Block number
- `gas_limit` (number): Gas the block could hold
- `gas_used` (number): Gas the block used
- `gas_used_percent` (number): How full the block was
- `miner` (text): Address of the validator that built the block
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `parent_hash` (text): Previous block's hash
- `size_bytes` (number): Block size in bytes
- `timestamp` (number): Block time as seconds since the Unix epoch
- `timestamp_iso` (text): Block time as ISO 8601 UTC
- `transaction_count` (number): Transactions in the block
- `transaction_hashes` (list): Their hashes, when asked for

**Example output**

```json
{
  "base_fee_per_gas_gwei": 0.412345678,
  "base_fee_per_gas_wei": "412345678",
  "block": "latest",
  "block_hash": "0x5c1e6e7f2d9a3b4c8e1f0a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d",
  "block_number": 23491027,
  "gas_limit": 36000000,
  "gas_used": 17842311,
  "gas_used_percent": 49.56,
  "miner": "0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5",
  "network": "eth-mainnet",
  "parent_hash": "0x3a2b1c0d9e8f7a6b5c4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f9a8b7c6d5e4f3a2b",
  "size_bytes": 94211,
  "timestamp": 1791283211,
  "timestamp_iso": "2026-10-06T10:40:11+00:00",
  "transaction_count": 187,
  "transaction_hashes": []
}
```

### Get event logs

Read the events a contract emitted, each with its block and time: every Transfer of a token, say, or every event of one kind from any contract. Given no block range it reads the last ten blocks, which suits a workflow on a schedule. Topic 0 is the event's signature hash (which event); topics 1-3 are its indexed arguments, and an address given as one is padded the way logs store it.

**Inputs**

- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- Contract address (`address`, text): The contract whose events to read. Leave blank to match the topics across every contract.
- Topics (`topics`, list): Up to four topic filters, in order. Each is a 32-byte topic, an address (which is padded for you), or blank to match anything in that position. Topic 0 is the event signature hash; the ERC-20 and ERC-721 Transfer event is 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
- From block (`from_block`, text): First block to read, as a number. Leave blank to read the last few blocks instead (see 'Last blocks').
- To block (`to_block`, text): Last block to read, as a number or 'latest'. Defaults to the latest block.
- Last blocks (`last_blocks`, number): When no 'From block' is given, how many of the most recent blocks to read. Defaults to 10, the most Alchemy's free plan allows per query on the busy chains; paid plans allow more. From 1 to 10000. Default: `10`.

**Outputs**

- `address` (text): Contract the logs were read from, or null for all
- `block_count` (number): Blocks covered
- `count` (number): Number of rows returned
- `from_block` (number): First block read
- `logs` (list): The matching events, oldest first
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `to_block` (number): Last block read

**Example output**

```json
{
  "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
  "block_count": 10,
  "count": 1,
  "from_block": 23491018,
  "logs": [
    {
      "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "block_hash": "0x5c1e6e7f2d9a3b4c8e1f0a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d",
      "block_number": 23491027,
      "data": "0x000000000000000000000000000000000000000000000000000000000ee6b280",
      "event_signature": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "log_index": 245,
      "removed": false,
      "timestamp": 1791283211,
      "timestamp_iso": "2026-10-06T10:40:11+00:00",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
        "0x00000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
        "0x000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"
      ],
      "transaction_hash": "0x9b1fc1dd4a1b0a2c6d30e9ab7c5e6f8d3a2b1c0d9e8f7a6b5c4d3e2f1a0b9c8d",
      "transaction_index": 42
    }
  ],
  "network": "eth-mainnet",
  "to_block": 23491027
}
```

### Get gas price

Read what a transaction costs to send right now: the gas price the node suggests, the latest block's base fee, the priority fee that gets a transaction included promptly, and what a plain transfer would cost at those prices. The guard for a workflow that waits for gas to be cheap.

**Inputs**

- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `base_fee_per_gas_gwei` (number): Latest block's base fee in gwei
- `base_fee_per_gas_wei` (text): Latest block's base fee in wei, exact, as a string
- `block_number` (number): Latest block, which the base fee belongs to
- `gas_price_gwei` (number): Suggested gas price in gwei
- `gas_price_wei` (text): Suggested gas price in wei, exact, as a string
- `max_priority_fee_per_gas_gwei` (number): Suggested priority fee (tip) in gwei
- `max_priority_fee_per_gas_wei` (text): Suggested priority fee (tip) in wei, exact, as a string
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `symbol` (text): The chain's own coin, which fees are paid in
- `transfer_fee` (number): Cost of a plain transfer (21,000 gas) in whole coins (ETH, POL, BNB...)
- `transfer_fee_string` (text): Cost of a plain transfer (21,000 gas) in whole coins as an exact decimal string
- `transfer_fee_wei` (text): Cost of a plain transfer (21,000 gas) in wei, exact, as a string

**Example output**

```json
{
  "base_fee_per_gas_gwei": 0.412345678,
  "base_fee_per_gas_wei": "412345678",
  "block_number": 23491027,
  "gas_price_gwei": 0.512345678,
  "gas_price_wei": "512345678",
  "max_priority_fee_per_gas_gwei": 0.1,
  "max_priority_fee_per_gas_wei": "100000000",
  "network": "eth-mainnet",
  "symbol": "ETH",
  "transfer_fee": 1.0759259238e-05,
  "transfer_fee_string": "0.000010759259238",
  "transfer_fee_wei": "10759259238000"
}
```

### Get historical token prices

Get a token's USD price over time, by symbol or by contract address: daily points for the last 30 days unless told otherwise, hourly for up to 30 days, or every five minutes for up to a week. The first, last, lowest and highest prices and the change over the window come worked out.

**Inputs**

- Symbol (`symbol`, text): The token's ticker symbol, such as ETH. Give this or a token contract, not both.
- Token contract address (`token_contract`, text): The token's contract address, with its network, instead of a symbol.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- Interval (`interval`, text): How far apart the price points are. Daily by default. One of: `1d` (Daily), `1h` (Hourly), `5m` (Every 5 minutes). Default: `1d`.
- Start (`start_time`, date and time): Start of the window. Leave blank for 30 days before the end (daily), 7 days (hourly) or 1 day (five-minute).
- End (`end_time`, date and time): End of the window. Leave blank for now.
- Include market data (`include_market_data`, true/false): Also return market cap and 24-hour volume at each point. Default: `false`.

**Outputs**

- `change_percent` (number): Change from first to last point, in percent
- `count` (number): Number of rows returned
- `currency` (text): 'usd'
- `end_time` (text): Window end (ISO 8601)
- `first_price_usd` (number): First point's price
- `highest_price_usd` (number): Highest price
- `interval` (text): '5m', '1h' or '1d'
- `last_price_usd` (number): Last point's price
- `lowest_price_usd` (number): Lowest price
- `network` (text): Network, when asked for by address
- `prices` (list): Price points, oldest first
- `start_time` (text): Window start (ISO 8601)
- `symbol` (text): Symbol, when known
- `token_contract` (text): Contract, when asked for by address

**Example output**

```json
{
  "change_percent": 2.4,
  "count": 3,
  "currency": "usd",
  "end_time": "2026-10-06T10:40:11Z",
  "first_price_usd": 1912.55,
  "highest_price_usd": 1958.4,
  "interval": "1d",
  "last_price_usd": 1958.4,
  "lowest_price_usd": 1912.55,
  "network": null,
  "prices": [
    {
      "market_cap_usd": null,
      "price_string": "1912.55",
      "price_usd": 1912.55,
      "timestamp": "2026-10-04T00:00:00Z",
      "total_volume_usd": null
    },
    {
      "market_cap_usd": null,
      "price_string": "1934.1",
      "price_usd": 1934.1,
      "timestamp": "2026-10-05T00:00:00Z",
      "total_volume_usd": null
    },
    {
      "market_cap_usd": null,
      "price_string": "1958.4",
      "price_usd": 1958.4,
      "timestamp": "2026-10-06T00:00:00Z",
      "total_volume_usd": null
    }
  ],
  "start_time": "2026-10-03T10:40:11Z",
  "symbol": "ETH",
  "token_contract": null
}
```

### Get native balance

Get an address's balance of the chain's own coin: ETH on Ethereum and its L2s, POL on Polygon, BNB on BNB Smart Chain. Returns the exact wei figure and the same amount in whole coins. An address that has never been used reads as zero.

**Inputs**

- Address (`address`, text, required): The wallet or contract address to read.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- Block (`block`, text): The block to read at: a block number, or 'latest', 'safe', 'finalized', 'earliest' or 'pending'. Leave blank for the latest block. Default: `latest`.

**Outputs**

- `address` (text): Address the balance is for
- `balance` (number): Balance in whole coins (ETH, POL, BNB...)
- `balance_string` (text): Balance in whole coins as an exact decimal string
- `balance_wei` (text): Balance in wei, exact, as a string
- `block` (text): Block it was read at
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `symbol` (text): The coin, e.g. 'ETH'

**Example output**

```json
{
  "address": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "balance": 4.512345678901235,
  "balance_string": "4.512345678901234567",
  "balance_wei": "4512345678901234567",
  "block": "latest",
  "network": "eth-mainnet",
  "symbol": "ETH"
}
```

### Get NFT collection

Get an NFT collection's details from its contract: name, symbol, total supply, token standard, who deployed it and when, and its OpenSea profile with description, links, verification status and floor price.

**Inputs**

- Collection contract address (`contract_address`, text, required): The NFT collection's contract address, for example 0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d for Bored Ape Yacht Club.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `banner_image_url` (text): Banner image
- `collection_name` (text): Name on OpenSea
- `collection_slug` (text): OpenSea slug
- `contract_address` (text): The contract
- `deployed_block_number` (number): Block it was deployed in
- `deployer` (text): Address that deployed it
- `description` (text): OpenSea description
- `discord_url` (text): Discord invite
- `external_url` (text): Project website
- `floor_price_eth` (number): OpenSea floor price in ETH
- `image_url` (text): Collection image
- `name` (text): Contract name
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `symbol` (text): Contract symbol
- `token_type` (text): 'ERC721' or 'ERC1155'
- `total_supply` (number): Tokens minted
- `twitter_username` (text): Twitter handle
- `verified` (true/false): Whether OpenSea has verified the collection

**Example output**

```json
{
  "banner_image_url": "https://i.seadn.io/gae/i5dYZRkVCUK97bfprQ3WXyrT9BnLSZtVKGJlKQ919uaUB0sxbngVCioaiyu9r6snqfi2aaTyIvv6DHm4m2R3y7hMajbsv14pSZK8mhs",
  "collection_name": "Bored Ape Yacht Club",
  "collection_slug": "boredapeyachtclub",
  "contract_address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
  "deployed_block_number": 12287507,
  "deployer": "0xaba7161a7fb69c88e16ed9f455ce62b791ee4d03",
  "description": "The Bored Ape Yacht Club is a collection of 10,000 unique Bored Ape NFTs.",
  "discord_url": "https://discord.gg/3P5K3dzgdB",
  "external_url": "https://boredapeyachtclub.com",
  "floor_price_eth": 10.49,
  "image_url": "https://i.seadn.io/gae/Ju9CkWtV-1Okvf45wo8UctR-M9He2PjILP0oOvxE89AyiPPGtrR3gysu1Zgy0hjd2xKIgjJJtWIc0ybj4Vd7wv8t3pxDGHoJBzDB",
  "name": "BoredApeYachtClub",
  "network": "eth-mainnet",
  "symbol": "BAYC",
  "token_type": "ERC721",
  "total_supply": 10000,
  "twitter_username": "BoredApeYC",
  "verified": true
}
```

### Get NFT floor price

Get a collection's floor price on the marketplaces Alchemy watches (OpenSea on Ethereum, Arbitrum and Base), and the lowest current one. Alchemy stopped refreshing LooksRare in early 2025: its old price is still listed, with when it was read, but a price read more than a week ago is never picked as the floor.

**Inputs**

- Collection contract address (`contract_address`, text, required): The NFT collection's contract address, for example 0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d for Bored Ape Yacht Club.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `collection_url` (text): The collection's page on that marketplace
- `contract_address` (text): The collection
- `currency` (text): Its currency, e.g. 'ETH'
- `floor_price` (number): Lowest floor read in the last week across the marketplaces, or null
- `marketplace` (text): Marketplace with that floor
- `marketplaces` (list): Every marketplace's reading
- `network` (text): Network the answer came from, e.g. eth-mainnet

**Example output**

```json
{
  "collection_url": "https://opensea.io/collection/boredapeyachtclub",
  "contract_address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
  "currency": "ETH",
  "floor_price": 10.49,
  "marketplace": "OpenSea",
  "marketplaces": [
    {
      "collection_url": "https://opensea.io/collection/boredapeyachtclub",
      "currency": "ETH",
      "error": null,
      "floor_price": 10.49,
      "marketplace": "OpenSea",
      "retrieved_at": "2026-10-06T10:35:02.144Z"
    },
    {
      "collection_url": "https://looksrare.org/collections/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
      "currency": "ETH",
      "error": null,
      "floor_price": 69.0,
      "marketplace": "LooksRare",
      "retrieved_at": "2025-01-13T03:42:07.872Z"
    }
  ],
  "network": "eth-mainnet"
}
```

### Get NFT metadata

Get one NFT by collection and token id: its name, description, image, traits and collection. Get NFT owners says who holds it.

**Inputs**

- Collection contract address (`contract_address`, text, required): The NFT collection's contract address, for example 0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d for Bored Ape Yacht Club.
- Token ID (`token_id`, text, required): The NFT's token id within the collection, as a number such as 1234.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- Refresh metadata (`refresh`, true/false): Make Alchemy re-read the metadata from its source instead of serving its cached copy. Slower; use it when an NFT's image or traits have just changed. Default: `false`.

**Outputs**

- `acquired_at` (text): When the holder received it (ISO 8601), where known
- `attributes` (list): The NFT's traits
- `balance` (number): How many the holder owns (always 1 for ERC-721)
- `collection_name` (text): Name of the collection
- `collection_slug` (text): The collection's OpenSea slug, when it has one
- `collection_symbol` (text): Symbol of the collection's contract
- `contract_address` (text): Contract of the collection the NFT belongs to
- `description` (text): Description from its metadata
- `external_url` (text): Link the metadata points to
- `floor_price_eth` (number): The collection's OpenSea floor price in ETH, if known
- `image_url` (text): Image, served from Alchemy's cache where it has one
- `is_spam` (true/false): Whether Alchemy classifies the collection as spam
- `last_updated_at` (text): When Alchemy last refreshed the metadata (ISO 8601)
- `name` (text): Name from the NFT's metadata
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `thumbnail_url` (text): A smaller copy of the image
- `token_id` (text): Token id within the collection
- `token_type` (text): 'ERC721' or 'ERC1155'
- `token_uri` (text): Where the metadata lives

**Example output**

```json
{
  "acquired_at": null,
  "attributes": [
    {
      "trait_type": "Mouth",
      "value": "Grin"
    },
    {
      "trait_type": "Clothes",
      "value": "Vietnam Jacket"
    },
    {
      "trait_type": "Background",
      "value": "Orange"
    },
    {
      "trait_type": "Eyes",
      "value": "Blue Beams"
    },
    {
      "trait_type": "Fur",
      "value": "Robot"
    }
  ],
  "balance": null,
  "collection_name": "Bored Ape Yacht Club",
  "collection_slug": "boredapeyachtclub",
  "collection_symbol": "BAYC",
  "contract_address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
  "description": null,
  "external_url": null,
  "floor_price_eth": 10.49,
  "image_url": "https://nft-cdn.alchemy.com/eth-mainnet/9c0b7f0b1a1b3a1a2c4d5e6f7a8b9c0d",
  "is_spam": false,
  "last_updated_at": "2026-09-30T08:15:42.117Z",
  "name": "Bored Ape #1",
  "network": "eth-mainnet",
  "thumbnail_url": "https://res.cloudinary.com/alchemyapi/image/upload/thumbnailv2/eth-mainnet/9c0b7f0b1a1b3a1a2c4d5e6f7a8b9c0d",
  "token_id": "1",
  "token_type": "ERC721",
  "token_uri": "https://ipfs.io/ipfs/QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq/1"
}
```

### Get NFT owners

Get who holds one NFT. An ERC-721 token has one owner; an ERC-1155 token can have many, and all are listed.

**Inputs**

- Collection contract address (`contract_address`, text, required): The NFT collection's contract address, for example 0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d for Bored Ape Yacht Club.
- Token ID (`token_id`, text, required): The NFT's token id within the collection, as a number such as 1234.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `contract_address` (text): The collection
- `count` (number): Number of holders
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `owner` (text): The first holder, or null
- `owners` (list): Every holder's address
- `token_id` (text): The token

**Example output**

```json
{
  "contract_address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
  "count": 1,
  "network": "eth-mainnet",
  "owner": "0x46efbaedc92067e6d60e84ed6395099723252496",
  "owners": [
    "0x46efbaedc92067e6d60e84ed6395099723252496"
  ],
  "token_id": "1"
}
```

### Get NFTs owned by wallet

List the NFTs a wallet holds, each with its name, image, collection and floor price, spam left out. Narrow it to one or more collections, and page through a large wallet with the page key. Alchemy filters spam itself only on paid plans; on the free plan it is taken out of each page here, so a page can hold fewer NFTs than the page size, or none, with more still to come.

**Inputs**

- Owner (`owner`, text, required): The wallet address, or an ENS name such as vitalik.eth.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- Collections (`contract_addresses`, list): Only NFTs from these collections, by contract address (up to 45). Leave blank for every collection.
- Exclude spam (`exclude_spam`, true/false): Leave out collections Alchemy classifies as spam: airdropped junk most wallets are full of. On by default, and on every plan: where the plan lacks Alchemy's own filter, spam is dropped from each page after it arrives. Default: `true`.
- Newest first (`newest_first`, true/false): Order by when the wallet received each NFT, most recent first, instead of by collection. Alchemy does not sort this way for every network and app; where it does not, the step fails rather than list the NFTs in the wrong order. Default: `false`.
- Page size (`page_size`, number): How many NFTs per page, from 1 to 100. Defaults to 25. From 1 to 100. Default: `25`.
- Page key (`page_key`, text): The 'page_key' a previous run of this step returned, to fetch the next page. Leave blank for the first page.

**Outputs**

- `count` (number): Number of rows returned
- `has_more` (true/false): Whether another page follows this one
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `nfts` (list): The NFTs on this page
- `owner` (text): Owner as given
- `page_key` (text): Pass as 'page_key' to fetch the next page; null on the last one
- `total_count` (number): NFTs the wallet holds in all, across every page; spam included where the plan leaves spam to be dropped here

**Example output**

```json
{
  "count": 1,
  "has_more": false,
  "network": "eth-mainnet",
  "nfts": [
    {
      "acquired_at": "2021-05-01T01:12:10Z",
      "attributes": [
        {
          "trait_type": "Mouth",
          "value": "Grin"
        },
        {
          "trait_type": "Clothes",
          "value": "Vietnam Jacket"
        },
        {
          "trait_type": "Background",
          "value": "Orange"
        },
        {
          "trait_type": "Eyes",
          "value": "Blue Beams"
        },
        {
          "trait_type": "Fur",
          "value": "Robot"
        }
      ],
      "balance": 1,
      "collection_name": "Bored Ape Yacht Club",
      "collection_slug": "boredapeyachtclub",
      "collection_symbol": "BAYC",
      "contract_address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
      "description": null,
      "external_url": null,
      "floor_price_eth": 10.49,
      "image_url": "https://nft-cdn.alchemy.com/eth-mainnet/9c0b7f0b1a1b3a1a2c4d5e6f7a8b9c0d",
      "is_spam": false,
      "last_updated_at": "2026-09-30T08:15:42.117Z",
      "name": "Bored Ape #1",
      "network": "eth-mainnet",
      "thumbnail_url": "https://res.cloudinary.com/alchemyapi/image/upload/thumbnailv2/eth-mainnet/9c0b7f0b1a1b3a1a2c4d5e6f7a8b9c0d",
      "token_id": "1",
      "token_type": "ERC721",
      "token_uri": "https://ipfs.io/ipfs/QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq/1"
    }
  ],
  "owner": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "page_key": null,
  "total_count": 1
}
```

### Get token allowance

Get how much of a token a spender (an exchange, a bridge, a contract) is approved to move on a wallet's behalf. An unlimited approval is flagged as such rather than reported as a 78-digit number. Useful for auditing what a wallet has let contracts spend.

**Inputs**

- Token contract address (`token_contract`, text, required): The ERC-20 token's contract address, for example 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 for USDC on Ethereum.
- Owner address (`owner`, text, required): The wallet that granted the approval.
- Spender address (`spender`, text, required): The address allowed to spend: a contract or a wallet.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `allowance` (number): Allowance in whole tokens, with the decimals applied
- `allowance_raw` (text): Allowance in the token's smallest unit, exact
- `allowance_string` (text): Allowance in whole tokens as an exact decimal string
- `decimals` (number): The token's decimals
- `has_allowance` (true/false): False when nothing is approved
- `is_unlimited` (true/false): True for an approval of (near) the maximum amount
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `owner` (text): Wallet that approved
- `spender` (text): Address approved to spend
- `symbol` (text): The token's symbol
- `token_contract` (text): The token

**Example output**

```json
{
  "allowance": 500.0,
  "allowance_raw": "500000000",
  "allowance_string": "500",
  "decimals": 6,
  "has_allowance": true,
  "is_unlimited": false,
  "network": "eth-mainnet",
  "owner": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "spender": "0xef1c6e67703c7bd7107eed8303fbe6ec2554bf6b",
  "symbol": "USDC",
  "token_contract": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
}
```

### Get token balance

Get how much of one ERC-20 token a wallet holds, in whole tokens as well as the exact raw figure, together with the token's name, symbol and decimals. The step behind 'how much USDC does this wallet have'.

**Inputs**

- Wallet address (`owner`, text, required): The wallet whose balance to read.
- Token contract address (`token_contract`, text, required): The ERC-20 token's contract address, for example 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 for USDC on Ethereum.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `balance` (number): Balance in whole tokens, with the decimals applied
- `balance_raw` (text): Balance in the token's smallest unit, exact
- `balance_string` (text): Balance in whole tokens as an exact decimal string
- `decimals` (number): Decimal places the token uses, e.g. 6 for USDC
- `logo` (text): URL of the token's logo, or null
- `name` (text): Token name, e.g. 'USD Coin'
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `owner` (text): Wallet the balance is for
- `symbol` (text): Ticker symbol, e.g. 'USDC'
- `token_contract` (text): The token

**Example output**

```json
{
  "balance": 1250.45,
  "balance_raw": "1250450000",
  "balance_string": "1250.45",
  "decimals": 6,
  "logo": "https://static.alchemyapi.io/images/assets/3408.png",
  "name": "USD Coin",
  "network": "eth-mainnet",
  "owner": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "symbol": "USDC",
  "token_contract": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
}
```

### Get token metadata

Get an ERC-20 token's name, symbol, decimals and logo from its contract address. The decimals are what turn a raw on-chain amount into a number a person reads.

**Inputs**

- Token contract address (`token_contract`, text, required): The ERC-20 token's contract address, for example 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 for USDC on Ethereum.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `decimals` (number): Decimal places the token uses, e.g. 6 for USDC
- `is_known` (true/false): False when the contract reports neither a name nor a symbol, which usually means it is not a token
- `logo` (text): URL of the token's logo, or null
- `name` (text): Token name, e.g. 'USD Coin'
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `symbol` (text): Ticker symbol, e.g. 'USDC'
- `token_contract` (text): The token

**Example output**

```json
{
  "decimals": 6,
  "is_known": true,
  "logo": "https://static.alchemyapi.io/images/assets/3408.png",
  "name": "USD Coin",
  "network": "eth-mainnet",
  "symbol": "USDC",
  "token_contract": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
}
```

### Get token prices by address

Get the current USD price of up to 25 tokens by contract address on one network, for tokens whose symbol is ambiguous or unknown. Returns one row per token plus an address-to-price lookup.

**Inputs**

- Token contracts (`addresses`, list, required): The tokens' contract addresses, up to 25.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `addresses` (list): Contracts asked for
- `by_address` (object): Contract to USD price, for the tokens that have one
- `count` (number): Number of rows returned
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `prices` (list): One row per token asked for

**Example output**

```json
{
  "addresses": [
    "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "0xdac17f958d2ee523a2206206994597c13d831ec7"
  ],
  "by_address": {
    "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48": 1.0026,
    "0xdac17f958d2ee523a2206206994597c13d831ec7": 0.9998
  },
  "count": 2,
  "network": "eth-mainnet",
  "prices": [
    {
      "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "currency": "usd",
      "error": null,
      "last_updated_at": "2026-10-06T10:39:50Z",
      "network": "eth-mainnet",
      "price_usd": 1.0026
    },
    {
      "address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
      "currency": "usd",
      "error": null,
      "last_updated_at": "2026-10-06T10:39:50Z",
      "network": "eth-mainnet",
      "price_usd": 0.9998
    }
  ]
}
```

### Get token prices by symbol

Get the current USD price of up to 25 tokens by ticker symbol: ETH, BTC, SOL, USDC and so on. Returns one row per symbol plus a symbol-to-price lookup for the next step.

**Inputs**

- Symbols (`symbols`, list, required): The tokens' ticker symbols, up to 25.

**Outputs**

- `by_symbol` (object): Symbol to USD price, for the tokens that have one
- `count` (number): Number of rows returned
- `prices` (list): One row per token asked for
- `symbols` (list): Symbols asked for

**Example output**

```json
{
  "by_symbol": {
    "BTC": 64231.17,
    "ETH": 1958.4
  },
  "count": 2,
  "prices": [
    {
      "currency": "usd",
      "error": null,
      "last_updated_at": "2026-10-06T10:39:50Z",
      "price_usd": 1958.4,
      "symbol": "ETH"
    },
    {
      "currency": "usd",
      "error": null,
      "last_updated_at": "2026-10-06T10:39:50Z",
      "price_usd": 64231.17,
      "symbol": "BTC"
    }
  ],
  "symbols": [
    "ETH",
    "BTC"
  ]
}
```

### Get transaction

Get a transaction by hash together with its receipt: whether it succeeded, when it landed, who sent what to whom, and the fee it paid. Use it to confirm a payment went through and for how much.

**Inputs**

- Transaction hash (`transaction_hash`, text, required): The 66-character transaction hash an explorer or 'Get transfer history' shows.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.

**Outputs**

- `block_hash` (text): Hash of that block
- `block_number` (number): Block it landed in
- `contract_address` (text): Contract it created, if it was a deployment
- `effective_gas_price_gwei` (number): Gas price actually paid in gwei
- `effective_gas_price_wei` (text): Gas price actually paid in wei, exact, as a string
- `fee` (number): Fee paid (gas used x effective gas price) in whole coins (ETH, POL, BNB...)
- `fee_string` (text): Fee paid (gas used x effective gas price) in whole coins as an exact decimal string
- `fee_wei` (text): Fee paid (gas used x effective gas price) in wei, exact, as a string
- `from` (text): Sender
- `gas_limit` (number): Gas limit set
- `gas_price_gwei` (number): Gas price offered in gwei
- `gas_price_wei` (text): Gas price offered in wei, exact, as a string
- `gas_used` (number): Gas actually used
- `input` (text): The call data, as hex
- `is_contract_call` (true/false): Whether it carried call data
- `log_count` (number): Events it emitted
- `logs` (list): The events it emitted
- `max_fee_per_gas_gwei` (number): Max fee per gas (EIP-1559) in gwei
- `max_fee_per_gas_wei` (text): Max fee per gas (EIP-1559) in wei, exact, as a string
- `max_priority_fee_per_gas_gwei` (number): Max priority fee (EIP-1559) in gwei
- `max_priority_fee_per_gas_wei` (text): Max priority fee (EIP-1559) in wei, exact, as a string
- `method_id` (text): First four bytes of the call data (which function)
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `nonce` (number): Sender's nonce
- `pending` (true/false): True while the transaction is not yet in a block
- `status` (text): 'succeeded', 'failed' or 'pending'
- `succeeded` (true/false): Whether it ran without reverting; null while pending
- `symbol` (text): The coin the value is in
- `timestamp` (number): Block time as seconds since the Unix epoch
- `timestamp_iso` (text): Block time as ISO 8601 UTC
- `to` (text): Recipient, or null when it created a contract
- `transaction_hash` (text): The hash
- `transaction_index` (number): Position in the block
- `type` (number): Transaction type: 0 legacy, 2 EIP-1559
- `value` (number): Value sent in whole coins (ETH, POL, BNB...)
- `value_string` (text): Value sent in whole coins as an exact decimal string
- `value_wei` (text): Value sent in wei, exact, as a string

**Example output**

```json
{
  "block_hash": "0x5c1e6e7f2d9a3b4c8e1f0a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d",
  "block_number": 23491027,
  "contract_address": null,
  "effective_gas_price_gwei": 0.512345678,
  "effective_gas_price_wei": "512345678",
  "fee": 2.4701722173414e-05,
  "fee_string": "0.000024701722173414",
  "fee_wei": "24701722173414",
  "from": "0x28c6c06298d514db089934071355e5743bf21d60",
  "gas_limit": 90000,
  "gas_price_gwei": 0.512345678,
  "gas_price_wei": "512345678",
  "gas_used": 48213,
  "input": "0xa9059cbb000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045000000000000000000000000000000000000000000000000000000000ee6b280",
  "is_contract_call": true,
  "log_count": 1,
  "logs": [
    {
      "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "block_hash": "0x5c1e6e7f2d9a3b4c8e1f0a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d",
      "block_number": 23491027,
      "data": "0x000000000000000000000000000000000000000000000000000000000ee6b280",
      "event_signature": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "log_index": 245,
      "removed": false,
      "timestamp": 1791283211,
      "timestamp_iso": "2026-10-06T10:40:11+00:00",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
        "0x00000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
        "0x000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"
      ],
      "transaction_hash": "0x9b1fc1dd4a1b0a2c6d30e9ab7c5e6f8d3a2b1c0d9e8f7a6b5c4d3e2f1a0b9c8d",
      "transaction_index": 42
    }
  ],
  "max_fee_per_gas_gwei": 0.9,
  "max_fee_per_gas_wei": "900000000",
  "max_priority_fee_per_gas_gwei": 0.1,
  "max_priority_fee_per_gas_wei": "100000000",
  "method_id": "0xa9059cbb",
  "network": "eth-mainnet",
  "nonce": 1849211,
  "pending": false,
  "status": "succeeded",
  "succeeded": true,
  "symbol": "ETH",
  "timestamp": 1791283211,
  "timestamp_iso": "2026-10-06T10:40:11+00:00",
  "to": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
  "transaction_hash": "0x9b1fc1dd4a1b0a2c6d30e9ab7c5e6f8d3a2b1c0d9e8f7a6b5c4d3e2f1a0b9c8d",
  "transaction_index": 42,
  "type": 2,
  "value": 0.0,
  "value_string": "0",
  "value_wei": "0"
}
```

### Get transfer history

List the transfers into or out of an address: the chain's own coin, ERC-20 tokens, and ERC-721 and ERC-1155 NFTs, newest first, each with its amount, asset and time. This is how a workflow watches a wallet or a token contract: filter by sender, recipient or token, and page through with the page key.

**Inputs**

- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- To address (`to_address`, text): Only transfers received by this address. Give this, 'From address', or a token contract, or any mix.
- From address (`from_address`, text): Only transfers sent by this address.
- Transfer types (`categories`, text): Which kinds of transfer to include. Defaults to the chain's own coin plus ERC-20, ERC-721 and ERC-1155 tokens. Internal transfers are only indexed on Ethereum and Polygon mainnet. One or more of: `external` (Native coin transfers), `erc20` (ERC-20 token transfers), `erc721` (ERC-721 NFT transfers), `erc1155` (ERC-1155 NFT transfers), `internal` (Internal transfers (Ethereum and Polygon only)), `specialnft` (Special NFTs (CryptoPunks, CryptoKitties)). Default: `["external", "erc20", "erc721", "erc1155"]`.
- Token contracts (`contract_addresses`, list): Only transfers of these tokens, by contract address. Leave blank for every asset.
- Max results (`max_count`, number): How many transfers to return, from 1 to 1000. Defaults to 25. From 1 to 1000. Default: `25`.
- Order (`order`, text): Newest first unless told otherwise. One of: `desc` (Newest first), `asc` (Oldest first). Default: `desc`.
- From block (`from_block`, text): First block to search, as a number. Leave blank to search from the chain's beginning.
- To block (`to_block`, text): Last block to search, as a number or 'latest'. Defaults to the latest block.
- Exclude zero-value transfers (`exclude_zero_value`, true/false): Leave out transfers of nothing, which are mostly spam. On by default. Default: `true`.
- Page key (`page_key`, text): The 'page_key' a previous run of this step returned, to fetch the next page. Leave blank for the first page.

**Outputs**

- `categories` (list): Transfer types searched
- `count` (number): Number of rows returned
- `from_address` (text): Sender filter used
- `has_more` (true/false): Whether another page follows this one
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `order` (text): 'desc' or 'asc'
- `page_key` (text): Pass as 'page_key' to fetch the next page; null on the last one
- `to_address` (text): Recipient filter used
- `transfers` (list): The transfers, in the order asked for

**Example output**

```json
{
  "categories": [
    "external",
    "erc20",
    "erc721",
    "erc1155"
  ],
  "count": 1,
  "from_address": null,
  "has_more": false,
  "network": "eth-mainnet",
  "order": "desc",
  "page_key": null,
  "to_address": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "transfers": [
    {
      "asset": "USDC",
      "block_number": 23491027,
      "category": "erc20",
      "decimals": 6,
      "erc1155": [],
      "from": "0x28c6c06298d514db089934071355e5743bf21d60",
      "raw_value": "250000000",
      "timestamp": 1791283211,
      "timestamp_iso": "2026-10-06T10:40:11.000Z",
      "to": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
      "token_contract": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "token_id": null,
      "transaction_hash": "0x9b1fc1dd4a1b0a2c6d30e9ab7c5e6f8d3a2b1c0d9e8f7a6b5c4d3e2f1a0b9c8d",
      "unique_id": "0x9b1fc1dd4a1b0a2c6d30e9ab7c5e6f8d3a2b1c0d9e8f7a6b5c4d3e2f1a0b9c8d:log:245",
      "value": 250.0
    }
  ]
}
```

### Get wallet tokens

Get every token a wallet holds across up to five networks at once, each with its balance, current USD price and what the holding is worth, plus the wallet's total. The one-step portfolio view: the chain's own coin and its ERC-20 tokens, most valuable first.

**Inputs**

- Wallet address (`address`, text, required): The wallet to read. The same address is read on every network chosen.
- Networks (`networks`, text): Which networks to read, up to 5. Ethereum Mainnet unless told otherwise. One or more of: `eth-mainnet` (Ethereum Mainnet), `base-mainnet` (Base), `arb-mainnet` (Arbitrum One), `opt-mainnet` (OP Mainnet), `polygon-mainnet` (Polygon PoS), `bnb-mainnet` (BNB Smart Chain), `avax-mainnet` (Avalanche C-Chain), `zksync-mainnet` (ZKsync Era), `linea-mainnet` (Linea), `scroll-mainnet` (Scroll), and 9 more. Default: `["eth-mainnet"]`.
- Include the chain's own coin (`include_native`, true/false): Include ETH, POL, BNB and so on. On by default. Default: `true`.
- Include ERC-20 tokens (`include_erc20`, true/false): Include the wallet's tokens. On by default. Default: `true`.
- Include empty balances (`include_zero_balances`, true/false): Also list tokens the wallet once held but holds none of now. Off by default. Default: `false`.
- Page key (`page_key`, text): The 'page_key' a previous run of this step returned, to fetch the next page. Leave blank for the first page.

**Outputs**

- `address` (text): Wallet read
- `count` (number): Number of rows returned
- `has_more` (true/false): Whether another page follows this one
- `networks` (list): Networks read
- `page_key` (text): Pass as 'page_key' to fetch the next page; null on the last one
- `tokens` (list): Holdings, most valuable first
- `total_value_usd` (number): What everything listed is worth in USD

**Example output**

```json
{
  "address": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "count": 2,
  "has_more": false,
  "networks": [
    "eth-mainnet"
  ],
  "page_key": null,
  "tokens": [
    {
      "balance": 4.512345678901235,
      "balance_raw": "4512345678901234567",
      "balance_string": "4.512345678901234567",
      "decimals": 18,
      "is_native": true,
      "logo": null,
      "name": "ETH",
      "network": "eth-mainnet",
      "price_updated_at": "2026-10-06T10:39:50Z",
      "price_usd": 1958.4,
      "symbol": "ETH",
      "token_address": null,
      "value_usd": 8836.98
    },
    {
      "balance": 1250.45,
      "balance_raw": "1250450000",
      "balance_string": "1250.45",
      "decimals": 6,
      "is_native": false,
      "logo": "https://static.alchemyapi.io/images/assets/3408.png",
      "name": "USD Coin",
      "network": "eth-mainnet",
      "price_updated_at": "2026-10-06T10:39:50Z",
      "price_usd": 1.0026,
      "symbol": "USDC",
      "token_address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "value_usd": 1253.7
    }
  ],
  "total_value_usd": 10090.68
}
```

### List NFTs in collection

List the NFTs a collection contains, in token id order, each with its name, image and traits. Page through a large collection with the page key.

**Inputs**

- Collection contract address (`contract_address`, text, required): The NFT collection's contract address, for example 0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d for Bored Ape Yacht Club.
- Network (`network`, text): Which chain to read. Ethereum Mainnet unless told otherwise. The list holds the networks most workflows use; any other network Alchemy serves can be typed in by its slug, such as 'sei-mainnet'. One key reaches every network enabled on its Alchemy app. Default: `eth-mainnet`.
- Page size (`limit`, number): How many NFTs per page, from 1 to 100. Defaults to 25. From 1 to 100. Default: `25`.
- Page key (`page_key`, text): The 'page_key' a previous run of this step returned, to fetch the next page. Leave blank for the first page.

**Outputs**

- `contract_address` (text): The collection
- `count` (number): Number of rows returned
- `has_more` (true/false): Whether another page follows this one
- `network` (text): Network the answer came from, e.g. eth-mainnet
- `nfts` (list): The NFTs on this page
- `page_key` (text): Pass as 'page_key' to fetch the next page; null on the last one

**Example output**

```json
{
  "contract_address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
  "count": 1,
  "has_more": true,
  "network": "eth-mainnet",
  "nfts": [
    {
      "acquired_at": null,
      "attributes": [
        {
          "trait_type": "Mouth",
          "value": "Grin"
        },
        {
          "trait_type": "Clothes",
          "value": "Vietnam Jacket"
        },
        {
          "trait_type": "Background",
          "value": "Orange"
        },
        {
          "trait_type": "Eyes",
          "value": "Blue Beams"
        },
        {
          "trait_type": "Fur",
          "value": "Robot"
        }
      ],
      "balance": null,
      "collection_name": "Bored Ape Yacht Club",
      "collection_slug": "boredapeyachtclub",
      "collection_symbol": "BAYC",
      "contract_address": "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
      "description": null,
      "external_url": null,
      "floor_price_eth": 10.49,
      "image_url": "https://nft-cdn.alchemy.com/eth-mainnet/9c0b7f0b1a1b3a1a2c4d5e6f7a8b9c0d",
      "is_spam": false,
      "last_updated_at": "2026-09-30T08:15:42.117Z",
      "name": "Bored Ape #1",
      "network": "eth-mainnet",
      "thumbnail_url": "https://res.cloudinary.com/alchemyapi/image/upload/thumbnailv2/eth-mainnet/9c0b7f0b1a1b3a1a2c4d5e6f7a8b9c0d",
      "token_id": "1",
      "token_type": "ERC721",
      "token_uri": "https://ipfs.io/ipfs/QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq/1"
    }
  ],
  "page_key": "0x0000000000000000000000000000000000000000000000000000000000000002"
}
```