Token Allowance Checker

One specific approval, read directly

The Token Allowance Checker reads a single, targeted ERC-20 approval: how much a spender address is allowed to move from an owner wallet’s balance. It resolves allowance(owner, spender) and decimals() in one call and returns the result as a decimal-formatted number, with unlimited and zero approvals called out explicitly so you don’t have to guess what a huge integer means. If you’re not certain the token address is actually ERC-20, the Contract Inspector confirms it exposes allowance before you rely on this reading.

How to use it

1. Paste the ERC-20 token contract address, the owner wallet, and the spender address into the form above.
2. Pick the chain the token and approval live on.
3. Run the query and read the result: the exact allowance, formatted with the token’s own decimals, plus a status flag for unlimited or zero approvals.

A result of zero is a valid, meaningful answer. It means the spender currently has no approval to move any of the owner’s tokens, which is common right after a revoke, or before a first-time approval has ever been granted.

Binding allowance and decimals in one expression

cel.bind(a, token.allowance(owner, spender),
  cel.bind(d, token.decimals(), {
    "allowance": string(formatUnits(a, d)),
    "symbol":    token.symbol()
  })
)

• token.allowance(owner, spender) reads the raw integer allowance the owner has granted to the spender.
• owner and spender are runtime context variables, declared as sol_address in the query schema and supplied as the wallet and spender addresses you enter in the form.
• cel.bind(a, …) reads the allowance once and reuses it, so it is only fetched a single time even though it appears in the formatted output.
• token.decimals() is read once via cel.bind(d, …) and used to scale the raw allowance into a human-readable number.
• formatUnits(a, d) divides the raw integer by 10 ** decimals server-side. It returns a double, so the result is wrapped in string(...) before it goes into the map, since CEL maps require every value to share a type and symbol() is already a string.
• Both reads are auto-batched by Multicall3, so the whole check costs one round trip regardless of how large the numbers are.

Check an allowance from your own code

Each of the snippets below makes the same POST call to the evmquery REST API. The example checks how much of USDC vitalik.eth’s wallet has approved Uniswap’s Permit2 contract to spend, on Ethereum.

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": { "token": { "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" } },
      "context": { "owner": "sol_address", "spender": "sol_address" }
    },
    "expression": "cel.bind(a, token.allowance(owner, spender), cel.bind(d, token.decimals(), { \"allowance\": string(formatUnits(a, d)), \"symbol\": token.symbol() }))",
    "context": {
      "owner": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
      "spender": "0x000000000022D473030F116dDEE9F6B43aC78BA3"
    }
  }'

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": {"token": {"address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"}},
            "context": {"owner": "sol_address", "spender": "sol_address"},
        },
        "expression": (
            "cel.bind(a, token.allowance(owner, spender),"
            " cel.bind(d, token.decimals(), {"
            ' "allowance": string(formatUnits(a, d)),'
            ' "symbol": token.symbol()'
            " }))"
        ),
        "context": {
            "owner": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
            "spender": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
        },
    },
    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: { token: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" } },
      context: { owner: "sol_address", spender: "sol_address" },
    },
    expression:
      'cel.bind(a, token.allowance(owner, spender), cel.bind(d, token.decimals(), { "allowance": string(formatUnits(a, d)), "symbol": token.symbol() }))',
    context: {
      owner: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
      spender: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
    },
  }),
});
const { result } = await resp.json();

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

Where a targeted allowance read replaces guessing

• Auditing a wallet’s active approvals. Before signing a new transaction, confirm exactly how much an existing spender can already move, instead of trusting a wallet UI’s rough estimate. If the token itself is unfamiliar, the ERC-20 Token Inspector confirms its name, symbol, and supply first.
• Verifying a revoke worked. After sending a approve(spender, 0) transaction, check the allowance reads back as zero.
• Reviewing a pending approval before you sign it. Decode the approve(spender, amount) calldata with the Calldata Decoder to see the exact amount a transaction would set, then use this checker afterward to confirm it actually landed.
• Security reviews and audits. Confirm a contract’s approval scope matches what the documentation claims before recommending it to users.
• Sizing the risk in dollar terms. An unlimited approval on a low-value token is a different risk than one on a token worth real money. Pair the token’s balance with a live price from the Chainlink Price Feed Reader to put a number on what’s actually exposed.
• Support and incident response. Quickly check whether a specific spender flagged in a phishing report actually has an active approval on a given wallet. If that spender is Aave’s Pool contract, the Aave Health Factor Checker shows what position it’s actually managing.

FAQ

Limits and accuracy

• This tool reads a single, targeted allowance for the owner and spender you supply. It does not scan a wallet for every approval it has ever granted, that requires indexing historical Approval events across every token contract, which is out of scope for a single on-chain read.
• 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.

Related

• ERC-20 Token Inspector: read the token’s name, symbol, decimals, and supply
• Calldata Decoder: decode a pending approve call before it sets a new allowance
• Contract Inspector: confirm a token contract actually exposes allowance
• Chainlink Price Feed Reader: price the token an allowance is exposed on
• Aave Health Factor Checker: see what an approved Aave Pool spender is actually managing
• Scan ERC-20 balances across many wallets from TypeScript: extend the same pattern to read balances across many wallets in one call
• 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
• evmquery’s free tools: try it yourself