Proxy Contract Detector

What this tool does

The Proxy Contract Detector reads any contract address and tells you whether it’s a proxy, which pattern it uses, and what it resolves to. It is built for developers and integrators who need a fast answer to one question before they interact with an address: is this contract forwarding my calls somewhere else, and if so, where?

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 status and resolved chain in the result panel.

The status line gives you the verdict directly: proxy detected, diamond proxy, or not a proxy. Below it, the 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. Diamond contracts render as a branching tree of facets instead of a single chain, with a facet count alongside. If the address is not a proxy, the panel says so directly and calls execute on the address you pasted. 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. Detecting this from bytecode alone means recognizing a handful of storage-slot and delegatecall conventions, not reading arbitrary logic. 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.
• Diamond contracts (EIP-2535) route different function selectors to different facet contracts. The tool detects the diamond hop and renders every resolved facet underneath it as a branch, not a chain, so you can see the fan-out at a glance.
• EIP-7702 delegation is resolved as its own hop kind. It is a distinct mechanism from a deployed proxy contract: an EOA temporarily executing delegated code via a signed authorization, not a storage-slot-routed forward.

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 interacting with an unfamiliar address. Confirm whether a contract is forwarding calls elsewhere before you trust its surface-level behavior.
• Sorting out proxy patterns. Tell Transparent, UUPS, Beacon, and Diamond proxies apart at a glance instead of tracing storage slots by hand.
• Checking a diamond’s facet spread. EIP-2535 diamonds split logic across many facets. The branching view shows how many are wired up without listing every method.
• Ruling proxies out. A clean “not a proxy” answer is a common, useful result on its own: it confirms calls execute directly on the address, no further resolution needed.

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

• Contract Inspector: the same resolved proxy chain plus the full method schema, for when you need to know what’s callable, not just what’s a proxy
• Gnosis Safe Inspector: inspect any Gnosis Safe multisig’s owners, threshold, and version, resolved through its proxy automatically
• evmquery for developers: the full integration story