Cover Raccoon API

Quickstart

Fastest path for an AI agent: add the MCP server to your host and ask it about a cover. No API key needed for the free tools.

1. Add the server to your host config (Claude Desktop, Cursor, or any MCP host):
   Copy

   {
     "mcpServers": {
       "coverraccoon": {
         "command": "npx",
         "args": ["-y", "coverraccoon-mcp"],
         "env": {
           "COVERRACCOON_PAYER_PRIVATE_KEY": "0x...  (USDC on Base or Polygon, optional)"
         }
       }
     }
   }

2. Restart the host so it loads the server.
3. Ask it: List DeFi covers on Cover Raccoon and check the best-scored one.

Direct HTTP integration, six steps: discover a product via cover-analyses (free), optionally preview the response shape via cover-schema (free), try check (free, no payment ever), pay via x402 only if you want the full analysis, optionally get a buy-quote and sign it yourself, then confirm the purchase. Each step is its own section below.

No auth, no payment. All of these except the catalog, schema and check are IP rate-limited (20 requests/minute); those three are cheap, cached, and left open for high-frequency use.

USDC on Base or Polygon, your choice: the 402 response's accepts[] array has one entry per network, pick whichever you hold USDC on. Sign an EIP-3009 authorization for that entry, retry with the X-PAYMENT header. Settle-before-deliver. The price shown is the current default; the authoritative number is always that entry's maxAmountRequired in the 402 response itself, since the default is configurable server-side.

Both check and the full analysis carry a signed attestation field, free or paid: a keccak256 digest of the canonical JSON payload, signed EIP-191. Verify it offline against the signer address published in x402.json's attestation.signer to prove provenance downstream.

Paying via x402

Three ways to pay, easiest first. Browser: open coverraccoon.com and sign in your wallet, nothing to code. Agent: the MCP server below signs and pays autonomously once you set a funded payer key. Direct integration: produce the X-PAYMENT header yourself, worked example below.

402 challenge, then retry

# 1) unpaid request -> HTTP 402 with a PaymentRequirements challenge
curl -i https://coverraccoon.com/api/cover/v1/analyses/nexus-mutual/uniswap-v3

# 2) pick a network from accepts[] (Base or Polygon), sign the EIP-3009
#    authorization for it (see below), base64-encode it, then retry with
#    the X-PAYMENT header
curl -s https://coverraccoon.com/api/cover/v1/analyses/nexus-mutual/uniswap-v3 \
  -H 'X-PAYMENT: <base64 payload>'

Signing the X-PAYMENT header (EIP-3009 TransferWithAuthorization)

// accepts[] has one entry per active network (Base, Polygon). Pick whichever
// you hold USDC on, call it "entry" below.
domain = {
  name: entry.extra.name,        // "USD Coin"
  version: entry.extra.version,  // "2"
  chainId: 8453,                 // 8453 for Base, 137 for Polygon
  verifyingContract: entry.asset // USDC contract address on that chain
}
types.TransferWithAuthorization = [
  { name: "from",        type: "address" },
  { name: "to",          type: "address" },
  { name: "value",       type: "uint256" },
  { name: "validAfter",  type: "uint256" },
  { name: "validBefore", type: "uint256" },
  { name: "nonce",       type: "bytes32"  }
]
message = {
  from: "<payer address>",
  to: entry.payTo,
  value: entry.maxAmountRequired,
  validAfter: "0",
  validBefore: "<now + maxTimeoutSeconds, unix seconds>",
  nonce: "<random 32-byte hex>"
}
// base64-encode { x402Version: 1, scheme: "exact", network: entry.network,
//   payload: { signature, authorization: message } } and send as X-PAYMENT.

An x402 client library (e.g. Coinbase's x402) or the MCP server produces this for you from a payer key. Prefer not to write signing code? Use the MCP, it does exactly this.

Buy cover

buy-quote is free: it returns a ready-to-sign transaction for the Nexus Mutual CoverBroker contract 0xCB2B736652D2dBf7d72e4dB880Cf6B7d99507814 on Ethereum mainnet (chainId 1). This is a different chain from the Base or Polygon x402 payments above (chainId 8453 / 137): the analysis you pay for and the cover you buy settle on different networks. Cover Raccoon never takes custody, you sign and submit the transaction yourself.

amount must already be in these smallest units when you call buy-quote, the same decimals are echoed back in the response's asset.decimals field. The response also carries a disclosed broker commission and mandatory compliance notices (cover wording, restricted countries, membership required for claims) that you must surface to your principal before they sign. After the transaction lands on-chain, POST the transaction hash to /api/cover/buy-confirm to have it verified.

Covered badge

GET /api/covered-badge/{wallet} is unrelated to the flow above: a standalone, free, live on-chain check whether a wallet, typically a DAO or protocol treasury, holds active user-protecting cover. It reads the wallet's Nexus Mutual cover NFTs on every call, so it cannot show expired protection as active. The full address is rendered inside the image as abuse protection: a badge copied onto someone else's site visibly shows an address that is not theirs.

<img src="https://coverraccoon.com/api/covered-badge/0xYourTreasuryAddress" alt="Users-covered badge" />

Agents · MCP

The coverraccoon-mcp package exposes every endpoint above as a tool for Claude Desktop, Cursor, or any MCP host. Set COVERRACCOON_PAYER_PRIVATE_KEY and the one paid tool, cover_analysis, pays autonomously (EIP-3009); otherwise it returns the payment requirements for you to handle. cover_check is free and never needs a key.

The same four tools also still work in the older reputa-mcp package under a reputa_ prefix (reputa_cover_list etc.), kept only so existing agent configurations do not break. New setups should use coverraccoon-mcp.

{
  "mcpServers": {
    "coverraccoon": {
      "command": "npx",
      "args": ["-y", "coverraccoon-mcp"],
      "env": {
        "COVERRACCOON_PAYER_PRIVATE_KEY": "0x...  (USDC on Base or Polygon, optional)"
      }
    }
  }
}

The payer key is a hot key that can spend USDC. Use a dedicated wallet with a small balance, never your main key. Each x402 charge is bounded (EIP-3009: exact amount, single-use nonce, short validity), so the most a single call can spend is the advertised price.

Resources

Read-only API. Analyses are dated snapshots with sources, not insurance advice and not a recommendation. Nexus Mutual cover pays out on a discretionary claims-assessment basis; buyers must become Nexus Mutual members to file a claim.