Contract Inspector

What this tool does

The Contract Inspector reads any contract address and returns two things: its resolved proxy chain and its full method schema. It is built for developers and integrators who need to know what they are actually calling before they write an ABI file or wire up an integration — whether an address is a proxy, what implementation it points to, and which methods are actually callable.

How to use it

1. Paste the contract address into the form above.
2. Pick the chain the contract is deployed to.
3. Run the query and read the proxy chain and method schema in the result panel.

The proxy chain panel shows the address you pasted, followed by each resolved hop and the pattern it matched, ending at the implementation the calls actually execute on. If the address is not a proxy, the panel says so directly and calls execute on the address you pasted. The method schema panel lists every resolved method with its inputs, outputs, the address it executes on, and where its ABI came from. A raw JSON toggle at the bottom shows the full response for debugging.

What is happening under the hood

Most non-trivial contracts on Ethereum are proxies: a thin contract that forwards every call to an implementation address it can upgrade independently. Reading a proxy’s own bytecode tells you almost nothing about what it does — you have to resolve the proxy pattern, follow it to the implementation, and pull the ABI from there. evmquery does this resolution server-side with the resolution include on POST /query/describe.

POST /query/describe
{
  "chain": "evm_ethereum",
  "schema": { "contracts": { "target": { "address": "0x..." } } },
  "include": ["resolution"]
}

• The response is a schema object listing every contract you asked about, each annotated with a resolution extension.
• A contract’s resolution.route is an ordered list of hops. Each hop has a kind — eip1967 and eip1967-beacon for the two most common transparent/beacon proxy standards, plus eip1822 (UUPS), eip1167 (minimal proxies), zeppelinos (OpenZeppelin’s legacy proxy), gnosis-safe, eip2535-diamond (multi-facet diamonds), eip7702-delegation, and generic getter/beacon-implementation hops — and a to address, the contract the call is forwarded to at that hop. An empty route means the address is not a proxy: calls execute directly on it.
• Each method in the schema carries its own resolution extension with executesAt (the address that method’s logic actually runs on, which is the end of the proxy chain for proxied contracts) and source, where its ABI was resolved from.
• ABI resolution tries verified source first (sourcify, etherscan), then falls back through code-reuse (matching known bytecode), metadata-ipfs, known-interface, and signature databases (openchain, fourbyte, evmole) when no verified source exists.
• Diamond contracts (EIP-2535) can expose methods across many facets. The schema flattens all of them into one method list, which is why the result panel includes a text filter.

Build this yourself

Each of the snippets below makes the same POST call to the evmquery REST API. The example targets USDC’s proxy contract on Ethereum, a legacy OpenZeppelin (zeppelinos) proxy, not an EIP-1967 one.

REST (curl)

curl -X POST https://api.evmquery.com/api/v1/query/describe \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "chain": "evm_ethereum",
    "schema": {
      "contracts": { "target": { "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" } }
    },
    "include": ["resolution"]
  }'

Python

import requests

resp = requests.post(
    "https://api.evmquery.com/api/v1/query/describe",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "chain": "evm_ethereum",
        "schema": {
            "contracts": {"target": {"address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"}},
        },
        "include": ["resolution"],
    },
    timeout=10,
)
print(resp.json())

TypeScript

const resp = await fetch("https://api.evmquery.com/api/v1/query/describe", {
  method: "POST",
  headers: {
    "x-api-key": process.env.EVMQUERY_API_KEY!,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    chain: "evm_ethereum",
    schema: {
      contracts: { target: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" } },
    },
    include: ["resolution"],
  }),
});
const schema = 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

• Before writing an ABI by hand. Confirm which address a contract’s calls actually execute on and what methods are really available before you hardcode an interface.
• Auditing an unfamiliar integration. Check whether a contract you are about to interact with is a proxy, and if so, what pattern it uses and where it points.
• Debugging a failed call. If a call to a proxy address behaves unexpectedly, the resolved method schema shows exactly which implementation address is handling it.
• Exploring diamond contracts. EIP-2535 diamonds spread their logic across many facets. The flattened, filterable method list makes it possible to see everything a diamond exposes in one place.

FAQ

Limits and accuracy

• The result reflects the contract’s current on-chain state at the time of the read. Proxies can be upgraded after the fact, so a route resolved today may point somewhere else tomorrow.
• The demo is rate limited per browser. If you hit the limit, grab a free API key and the limit goes away.

Related

• Proxy Contract Detector: a narrower read on the same resolved proxy chain, for when all you need is “is this a proxy”
• ERC-20 Token Inspector: read name, symbol, decimals, and supply for any token, proxy-aware
• Multicall3 batching for EVM contract reads: why one expression can replace dozens of eth_call round trips
• evmquery for developers: the full integration story