ERC-721 NFT Inspector

What this tool does

The ERC-721 Inspector reads any ERC-721 NFT contract and returns the name, symbol, tokenURI, and current owner from one expression. It is built for developers and collectors who need to inspect a specific token without writing ABI files or chasing IPFS gateways by hand.

How to use it

1. Paste the ERC-721 contract address into the form above.
2. Enter the token ID you want to inspect, then pick a chain.
3. Run the query and read the name, symbol, owner, tokenURI, and metadata in the result panel.

The result panel shows the collection name and symbol, the current owner address, the raw tokenURI(id) returned by the contract, the resolved metadata URL, and the read block number. Everything happens in one round trip to the contract.

What is happening under the hood

ERC-721 is simpler to query than ERC-1155: every token ID has its own owner and its own tokenURI, already resolved by the contract with no {id} placeholder to substitute. evmquery handles the contract reads in one expression. The frontend handles the gateway fetch for the metadata JSON.

{
  "name":     dyn(nft.name()),
  "symbol":   dyn(nft.symbol()),
  "tokenURI": dyn(nft.tokenURI(id)),
  "owner":    dyn(nft.ownerOf(id))
}

• name() and symbol() read the collection-level metadata exposed by the ERC-721 Metadata extension.
• tokenURI(id) returns the final metadata URL for that specific token. evmquery resolves the contract ABI from verified source and decodes the typed result.
• ownerOf(id) returns an address, while the other fields are strings. CEL maps need a single value type, so every field is wrapped in dyn(...), which yields a map<string, dyn> where each value serializes as its natural type (the owner comes back as a hex address).
• Multiple reads are auto-batched by Multicall3, so the cost is one round trip regardless of how many fields you ask for.

Build this yourself

Each of the snippets below makes the same POST call to the evmquery REST API. The expression is the one shown above, with your contract address and inputs filled in.

REST (curl)

curl -X POST https://api.evmquery.com/api/v1/query \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "chain": "evm_ethereum",
    "schema": {
      "contracts": { "nft": { "address": "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D" } },
      "context": { "id": "sol_int" }
    },
    "expression": "{ \"name\": dyn(nft.name()), \"symbol\": dyn(nft.symbol()), \"tokenURI\": dyn(nft.tokenURI(id)), \"owner\": dyn(nft.ownerOf(id)) }",
    "context": { "id": 1 }
  }'

Python

import requests

resp = requests.post(
    "https://api.evmquery.com/api/v1/query",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "chain": "evm_ethereum",
        "schema": {
            "contracts": {"nft": {"address": "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D"}},
            "context": {"id": "sol_int"},
        },
        "expression": (
            '{ "name": dyn(nft.name()), "symbol": dyn(nft.symbol()),'
            ' "tokenURI": dyn(nft.tokenURI(id)), "owner": dyn(nft.ownerOf(id)) }'
        ),
        "context": {"id": 1},
    },
    timeout=10,
)
print(resp.json()["result"])

TypeScript

const resp = await fetch("https://api.evmquery.com/api/v1/query", {
  method: "POST",
  headers: {
    "x-api-key": process.env.EVMQUERY_API_KEY!,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    chain: "evm_ethereum",
    schema: {
      contracts: {
        nft: { address: "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D" },
      },
      context: { id: "sol_int" },
    },
    expression:
      '{ "name": dyn(nft.name()), "symbol": dyn(nft.symbol()), "tokenURI": dyn(nft.tokenURI(id)), "owner": dyn(nft.ownerOf(id)) }',
    context: { id: 1n },
  }),
});
const { result } = await resp.json();

The free tier has no monthly cap. Get a free API key to drop these snippets into your project.

When you would use this

• Verifying provenance. Confirm who currently owns a specific token before you buy, accept as collateral, or feature it.
• Auditing a new collection. Quickly verify a contract really implements ERC-721 and inspect the metadata URI before you list or integrate it.
• Debugging an indexer. Compare the on-chain tokenURI(id) and ownerOf(id) results with what your indexer cached to find where it drifted.
• Writing ERC-721 docs. Show your readers a working tokenURI and ownerOf example without making them set up a Hardhat console.

FAQ

Limits and accuracy

• The result reflects the latest block at the time of the read. There is no historical replay.
• The demo is rate limited per browser. If you hit the limit, grab a free API key and the limit goes away.
• Image previews are loaded directly from the metadata image URL. If the gateway throttles or the image is missing, the preview is silently hidden.
• USD pricing, marketplace floor data, and royalty configuration are out of scope. evmquery returns raw on-chain values, not aggregated marketplace data.

Related

• Multicall3 batching for EVM contract reads: why one expression can replace dozens of eth_call round trips
• Read smart contracts in n8n: wire the same query into a no-code workflow
• Building an EVM blockchain MCP server: let Claude or Cursor inspect ERC-721 collections in chat
• evmquery for developers: the full integration story