Gnosis Safe Inspector

What this tool does

The Gnosis Safe Inspector reads any Safe{Wallet} (formerly Gnosis Safe) multisig and returns its owners, signature threshold, nonce, and contract version from one expression. It is built for developers, integrators, and anyone who wants to verify a Safe’s configuration before sending funds to it or building around it, without ABIs or a block explorer tab.

How to use it

1. Paste the Safe address into the form above.
2. Pick the chain the Safe is deployed on.
3. Run the query and read the signature threshold, nonce, version, and full owner list in the result panel.

The result panel shows the threshold as “N of M” (N signatures required out of M owners), the current nonce, the Safe contract version, and every owner address stacked below.

What is happening under the hood

A Gnosis Safe is deployed as a minimal proxy that delegates every call to a shared singleton implementation contract. evmquery detects that the address you paste is a Safe proxy and dispatches the reads to the correct implementation automatically, so you never need to look up or supply the implementation ABI yourself.

{
  "owners":     dyn(safe.getOwners()),
  "ownerCount": dyn(safe.getOwners().size()),
  "threshold":  dyn(string(formatUnits(safe.getThreshold(), 0))),
  "nonce":      dyn(string(formatUnits(safe.nonce(), 0))),
  "version":    dyn(safe.VERSION())
}

CEL map literals normally require every value in the map to share exactly one type. This expression needs to return an address array (owners), scalar integers (ownerCount, threshold, nonce), and a plain string (version) in a single response, which a strictly-typed map can’t hold at once. Wrapping every field in dyn(...) escapes that restriction and lets the map mix types.

That escape comes with a shape to know about: dyn() applied to a sol_int or a sol_address / list<sol_address> wraps each value as {"value": "<string>"}, while dyn() applied to a plain CEL string (like VERSION(), which the Safe contract already returns as a string) passes through unwrapped. A real response looks like:

{
  "owners": [{ "value": "0xe4df...ffed9" }, { "value": "0xa1cf..." }],
  "ownerCount": { "value": "5" },
  "threshold": { "value": "3" },
  "nonce": { "value": "8" },
  "version": "1.3.0"
}

So callers should read .value off owners, ownerCount, threshold, and nonce, but read version directly as a string.

Build this yourself

Each of the snippets below makes the same POST call to the evmquery REST API. The example targets GnosisDAO’s Safe 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": { "safe": { "address": "0x0da0c3e52c977ed3cbc641ff02dd271c3ed55afe" } }
    },
    "expression": "{ \"owners\": dyn(safe.getOwners()), \"ownerCount\": dyn(safe.getOwners().size()), \"threshold\": dyn(string(formatUnits(safe.getThreshold(), 0))), \"nonce\": dyn(string(formatUnits(safe.nonce(), 0))), \"version\": dyn(safe.VERSION()) }"
  }'

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": {"safe": {"address": "0x0da0c3e52c977ed3cbc641ff02dd271c3ed55afe"}},
        },
        "expression": (
            '{ "owners": dyn(safe.getOwners()),'
            ' "ownerCount": dyn(safe.getOwners().size()),'
            ' "threshold": dyn(string(formatUnits(safe.getThreshold(), 0))),'
            ' "nonce": dyn(string(formatUnits(safe.nonce(), 0))),'
            ' "version": dyn(safe.VERSION()) }'
        ),
    },
    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: { safe: { address: "0x0da0c3e52c977ed3cbc641ff02dd271c3ed55afe" } },
    },
    expression:
      '{ "owners": dyn(safe.getOwners()), "ownerCount": dyn(safe.getOwners().size()), "threshold": dyn(string(formatUnits(safe.getThreshold(), 0))), "nonce": dyn(string(formatUnits(safe.nonce(), 0))), "version": dyn(safe.VERSION()) }',
  }),
});
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 a Safe before sending funds. Confirm the owner set and threshold match what you expect before treating an address as a trusted multisig.
• Monitoring treasury or DAO Safes. Track nonce changes to detect new transactions, or watch for owner set changes that signal a governance action.
• Auditing integrations. Check the Safe contract version before building tooling that depends on version-specific behavior.
• Writing developer docs. Show readers a working Safe read example without making them set up a node, an ABI file, or the Safe SDK.

FAQ

Limits and accuracy

• The result reflects the latest block at the time of the read. There is no historical replay.
• The owner list has no pagination. Safe owner sets are small in practice, so every owner is returned in one response.
• The demo is rate limited per browser. If you hit the limit, grab a free API key and the limit goes away.

Related

• Token Allowance Checker: check what a spender is approved to move from a wallet
• ERC-20 Token Inspector: read any ERC-20 token’s name, symbol, decimals, and supply
• evmquery for developers: the full integration story