Token intelligence, one API call away

The DeFade API gives developers programmatic access to the same on-chain risk analysis that powers defade.org. Analyze any token for rug pull risk, insider networks, bundle manipulation, smart money activity, and more — all via a fast REST API. Every endpoint defaults to Solana; adding ?chain= runs the same analysis on Ethereum, Base, BSC, Robinhood, Arc or Hyperliquid for keys on an All-Chains plan — see Chains.

What can you build?

Trading bots that check rug risk before buying. Portfolio dashboards with real-time risk scoring. Telegram/Discord bots for community token screening. Browser extensions that warn users on DEX pages. Analytics platforms tracking insider activity across Solana, Ethereum, Base, BSC, Robinhood, Arc and Hyperliquid.

Quick Start

Make your first API call in under 60 seconds.

1. Get an API key

Paid plans are self-serve: pick Starter, Pro or Enterprise under Pricing (or at defade.org/developers), pay by card or crypto, and your key is shown on the confirmation page and emailed to you straight away. Want to try first? Request a free 7-day trial key and tell us what you're building; we review and email it, usually within 24 hours. Either way, send the key with every request in the x-api-key header. The same key also powers the MCP connector for Claude and ChatGPT.

2. Analyze a token

Use your key to run a full analysis on any Solana token mint address:

curl https://api.defade.org/v1/analyze/YOUR_TOKEN_MINT \
  -H "x-api-key: df_your_api_key"

const res = await fetch('https://api.defade.org/v1/analyze/YOUR_TOKEN_MINT', {
  headers: { 'x-api-key': 'df_your_api_key' }
});
const data = await res.json();
console.log(data.risk.score, data.risk.rating);

import requests

res = requests.get(
    'https://api.defade.org/v1/analyze/YOUR_TOKEN_MINT',
    headers={'x-api-key': 'df_your_api_key'}
)
data = res.json()
print(data['risk']['score'], data['risk']['rating'])

3. Interpret the results

Two endpoints score a token, on scales that run in OPPOSITE directions. Read this before wiring either into a threshold: rugScore counts UP toward danger, while risk.score counts DOWN toward it. A token scoring 85 is near-certain trouble on one and near-clean on the other.

/v1/rug-score — rugScore, 0 safe → 100 critical

The rug probability model. Higher is worse. verdict is the label, verdictColor the colour to render it in.

/v1/analyze — risk.score, 100 safe → 0 critical

The legacy safety score, carried on the risk object as score, rating, color and flags. Higher is safer — the inverse of rugScore, and a different set of labels. If you only need one number, use /v1/rug-score.

Authentication

All API requests require authentication via an API key.

Include your key using either the x-api-key request header (recommended) or the api_key query parameter. The header method is preferred as it keeps your key out of server logs and browser history.

curl https://api.defade.org/v1/rug-score/TOKEN_MINT \
  -H "x-api-key: df_your_api_key_here"

curl "https://api.defade.org/v1/rug-score/TOKEN_MINT?api_key=df_your_api_key_here"

Get an API Key

Buy a plan and the key is yours immediately, or request a free 7-day trial.

Paid plans are self-serve. Choose Starter, Pro or Enterprise under Pricing or on defade.org/developers and pay by card (Stripe) or crypto. The key is shown on the confirmation page and emailed to you the moment payment clears; no review, no waiting. Every paid plan covers every chain and every endpoint; the plans differ on monthly allowance and rate limit.

Free trial keys are issued on request. Submit the form at defade.org/developers#keygen with a short note on what you're building. We review each request and email a 7-day trial key, usually within 24 hours. Trial keys reach six endpoints (analyze, rug-score, token-price, holders, kol, trending) plus usage, on every chain we cover — Solana + Ethereum, Base, BSC, Robinhood, Arc, Hyperliquid — at 10 req/min, 100 req/day and 3,000 units/month.

An API-plan key works everywhere: the REST API from your own code and the MCP connector in Claude or ChatGPT, same plan, same quota. DeFade Pro web subscribers get a different, connector-only key from their dashboard; it reaches the connector's tools, spends the plan's monthly scan allowance, and is not valid on the REST API. See MCP connector → Getting a key.

Using your key

Send your key with every request in the x-api-key header (or as an api_key query parameter). Every paid plan can call all 25 endpoints on every chain; the plans differ on how many requests a month you get and how fast you may send them. See Authentication for details.

API Endpoints

25 endpoints covering every angle of on-chain risk. Click any endpoint to expand full details, parameters, and response schema. Every paid plan unlocks all 25 endpoints — plans differ on included volume, rate limit and chains. The second badge shows chain support: 23 run on every chain, bundles is Solana-only, and usage reports on your key so it has no chain at all (see Chains).

Every endpoint wraps its result in the same envelope: token (the mint you asked about), timestamp (when the response was assembled) and poweredBy, with the endpoint's own fields in between. Five exceptions: /v1/holder-overlap and /v1/wallet-overlap take several mints so they carry mints instead of token; /v1/wallet-reputation is about a wallet, so it carries wallet (and chain); /v1/trending is not about one token so it has no token; and /v1/usage reports on your key, so it has no envelope at all. On /v1/analyze the endpoint's own token object replaces the envelope's mint string.

Chains

One endpoint set, every chain. Solana is the default; ?chain= selects an EVM chain.

Every endpoint takes an optional chain query parameter. Omit it and the request is treated as Solana, so existing integrations keep working with no change. Pass it to run the same analysis on an EVM chain — the response shape is identical, only the addresses differ.

curl https://api.defade.org/v1/rug-score/7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU \
  -H "x-api-key: df_your_api_key_here"

curl "https://api.defade.org/v1/rug-score/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48?chain=base" \
  -H "x-api-key: df_your_api_key_here"

Supported chains

Plus solana (base58 mint address), which is the default when chain is omitted. Additional chains are added to this list as they launch — this table is generated from the live chain registry, so it always reflects what the API will actually answer for.

Which plans reach which chains

Chain access is a property of your plan, not of the endpoint. Every plan on sale covers every chain, with an identical endpoint list:

Requesting a chain your plan doesn't cover returns 403; only keys on a retired Solana-only plan (below) can hit this. Sending a 0x address without a chain, or a base58 mint with an EVM chain, returns 400 — the address format and the chain have to agree.

Endpoint coverage on EVM

23 of the 25 endpoints run on every chain. One is Solana-only, and usage has no chain:

/v1/usage reports on your key rather than on a token, so it takes no chain parameter. /v1/trending, /v1/holder-overlap, /v1/wallet-overlap and /v1/wallet-reputation accept chain as a normal query parameter alongside their own.

Overage Credits

Keep making requests after your daily limit — pay-per-use, no plan upgrade required.

When your daily request limit is reached, the API normally returns 429 Too Many Requests. With overage credits enabled, requests beyond your daily limit are automatically fulfilled using credits instead of being blocked. Each overage request costs 1 credit ($0.025).

How It Works

1. Purchase a credit pack via the dashboard (card or USDC) or the API. 2. Enable overage on your API key (opt-in via dashboard toggle). 3. When you hit your daily limit, requests automatically consume credits. 4. When credits run out, the standard 429 response resumes.

Buy Credits via API

Returns a Stripe checkout URL for one-time credit purchase. After payment, credits are added to your key automatically.

Response Headers

When a request uses an overage credit, two extra headers are included in the response:

429 Response with Credits Info

When your daily limit is hit and credits are unavailable or disabled, the 429 response includes a credits object:

{
  "error": "Daily limit exceeded",
  "limit": "1000/day",
  "resetsAt": "midnight UTC",
  "credits": {
    "enabled": false,
    "balance": 0,
    "costPerRequest": "$0.025",
    "hint": "Enable overage credits in your dashboard..."
  }
}

Rate Limits

Rate limits are enforced per API key at both per-minute and daily granularity.

When you exceed your per-minute rate limit, the API returns 429 Too Many Requests with a retryAfter field (in seconds). When you exceed your daily limit, the request is blocked unless you have overage credits enabled — in which case each extra request consumes 1 credit ($0.025). Rate limit status is included in every response via headers:

Limits by Plan

Error Handling

All errors return a consistent JSON structure with an error field and optionally a message with more detail.

Error Response Format

{
  "error": "Rate limit exceeded",
  "limit": "10/min",
  "retryAfter": 23
}

HTTP Status Codes

You pay for answers, not errors. A request refused for its shape (400) or by your plan (403, 429) is never charged, and a call that fails on our side (any 5xx, timeouts included) is given back: its units, or the credit it used, return to your allowance and it does not count toward your daily or per-minute limits. A module that answers pending or unavailable has answered, and is charged as usual.

SDKs & Integration

The DeFade API is a standard REST API — it works with any HTTP client in any language.

Official JavaScript SDK

Zero-dependency client for Node 18+, CJS and ESM, with TypeScript types — open source at github.com/DeFadeLtd/defade-sdk.

npm install defade   # or: npm install github:DeFadeLtd/defade-sdk

import DeFade from 'defade';

const client = new DeFade({ apiKey: process.env.DEFADE_API_KEY });

const scan = await client.analyze('TOKEN_MINT');            // safety score: 100 = clean
const risk = await client.rugScore('TOKEN_MINT');           // rug probability: 100 = dangerous
const eth  = await client.holders('0x…', { chain: 'ethereum' });

Plain JavaScript / Node.js

// Simple wrapper function
const DEFADE_KEY = process.env.DEFADE_API_KEY;

async function defade(endpoint, mint = '') {
  const url = `https://api.defade.org/v1/${endpoint}${mint ? `/${mint}` : ''}`;
  const res = await fetch(url, {
    headers: { 'x-api-key': DEFADE_KEY }
  });
  if (!res.ok) throw new Error(`DeFade API ${res.status}: ${(await res.json()).error}`);
  return res.json();
}

// Usage
const analysis = await defade('analyze', 'TOKEN_MINT');
const trending = await defade('trending');

Python

import os, requests

DEFADE_KEY = os.environ['DEFADE_API_KEY']
BASE = 'https://api.defade.org/v1'

def defade(endpoint, mint=''):
    url = f'{BASE}/{endpoint}' + (f'/{mint}' if mint else '')
    r = requests.get(url, headers={'x-api-key': DEFADE_KEY})
    r.raise_for_status()
    return r.json()

# Usage
analysis = defade('analyze', 'TOKEN_MINT')
trending = defade('trending')

Other Integrations

DeFade also offers a Telegram bot (@DeFadeAnalyzerBot) for instant token checks, a Chrome extension that auto-detects tokens on DEX pages, and a community channel at t.me/DeFadeChat.

MCP Connector

The same API, spoken as Model Context Protocol, so Claude, ChatGPT and any other MCP client can run DeFade scans directly in a conversation. One endpoint, no SDK, no separate key.

Connect

Add a custom connector pointing at the URL below, with your API key in the query string. Connector UIs only take a URL, which is why the key goes there; x-api-key and Authorization: Bearer also work for clients that let you set headers.

https://api.defade.org/mcp?api_key=YOUR_KEY

Claude — Settings → Connectors → Add custom connector → paste the URL. ChatGPT — Settings → Connectors → Add → paste the URL. Both then list DeFade's tools and call them when a question needs one.

Getting a key

Two keys open the connector, and they are different products:

An API-plan key (df_…). Buy Starter, Pro or Enterprise under Pricing or on defade.org/developers (card or crypto, key delivered immediately), or request a free 7-day trial. It works on the REST API and in the connector alike, metered in units against the plan. A trial key reaches only get_token_scan, get_rug_score, get_holders, get_token_price and get_usage, on any chain.

The Pro connector key (df_mcp_…), included with a DeFade Pro web subscription. Issue it from the dashboard under "Claude & ChatGPT connector" and paste the URL it gives you. It reaches all fifteen tools on every chain, and every tool call spends a scan from the plan's monthly allowance — the same one the website uses, one scan per distinct token per UTC day however many tools you run on it — so get_usage reports scans, not units. It only works through the connector: a direct REST call answers 403 mcp_only, and it stops working when the subscription lapses. It is not an API key, and it does not turn a Pro subscription into an API plan.

Tools

Fifteen tools, one per module, each mapping to the /v1 endpoint of the same name:

get_token_scan          get_rug_score           get_holders
get_whales              get_liquidity           get_launch_bundles
get_launch_snipers      get_wallet_links        get_smart_money
get_dev_tracker         get_funding_sources     get_lookalike_clusters
get_fee_fingerprint     get_token_price         get_usage

Every tool takes an address and an optional chain, exactly like the REST route behind it; get_token_price also takes an optional timeframe (the route's ?type=), so 1D reaches back up to a year of daily candles. Nothing here writes, trades or spends — all fifteen are read-only.

Billing and limits

A tool call is an API call: it runs through the same key, the same plan endpoint list, the same chain scope, the same unit quota and the same rate limits as a REST request, and shows up in your usage the same way. Connector traffic is tagged mcp on the usage dashboard so you can tell it apart from your own integrations. There is no separate MCP plan or price. With the Pro connector key the meter is the web plan's scan allowance instead (see Getting a key).

Two scores, opposite directions

Worth knowing before you read an assistant's answer: get_token_scan returns risk.score, a safety score where 100 is clean, while get_rug_score returns rugScore, a rug pull probability where high is dangerous. The connector states this in its handshake instructions and repeats it on every result, so a model should not confuse them — but if you are reading raw output, check which tool produced it.

Calling it directly

It is plain JSON-RPC 2.0 over HTTP POST (stateless Streamable HTTP — no session header, no SSE stream), so you can drive it with curl:

curl -X POST "https://api.defade.org/mcp?api_key=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

curl -X POST "https://api.defade.org/mcp?api_key=YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call",
       "params":{"name":"get_token_scan",
                 "arguments":{"address":"YOUR_MINT","chain":"solana"}}}'

A failed call comes back as a tool result with isError set and the API's own message inside it — wrong plan, bad address, allowance spent — rather than a bare protocol error, so the assistant can tell you what actually went wrong.

Changelog

Changes to the shape of a response, and anything else that can break an integration written against an earlier version. Endpoints added, and fields added to an existing response, are safe to ignore — they are listed so you know what is new.

2026-10-01 · Changed · /v1/rug-score answers within a time budget

The call used to run the full analysis first, then its Pro modules, and wait for the slowest of them — a median of 11–13 s and a 95th percentile at the 25 s ceiling. It now starts the launch modules alongside the analysis and answers after a budget, 5 s by default: the free checks and every module that has landed are scored, and the rest is named in a new pending array while it keeps computing server-side. complete is true when nothing is pending, and coverage reads partial until then. Pass ?wait=full to wait for every module as before (up to 25 s), or ?wait=<seconds> to choose your own budget. If your integration needs the complete score in one call, add ?wait=full. The MCP tool always waits for the complete answer.

2026-09-30 · Added · /v1/wallet-reputation/:wallet and /v1/wallet-overlap

/v1/wallet-reputation/:wallet is the Wallet Lookup page on the API: one wallet's record across every token DeFade scanned — tokens flagged in, confirmed rugs, the role on each, a tier verdict — with a labelGlossary that says what each role means. It is about a wallet rather than a token, so its envelope carries wallet and chain in place of token. /v1/wallet-overlap?mints=A,B(,C) returns the wallets holding two or more of the given tokens. Nothing about existing endpoints changed.

2026-09-07 · Breaking · /v1/trending?chain= returns a named array on EVM chains too

The 2026-08-28 fix below landed on the Solana path only. On ethereum, base and robinhood the feed was still spread into the envelope, so the same endpoint answered two different shapes depending on ?chain= — a named trending array on Solana, numeric keys everywhere else. The EVM response now carries the same trending array. If your integration reads numeric keys off an EVM trending call, change it to res.trending; the Solana path is unaffected, and an error still puts error at the top level rather than inside trending.

2026-09-07 · Added · trial keys reach every chain

The free 7-day trial key was Solana-only. It now covers every chain the API covers — Solana, Ethereum, Base and Robinhood — on the same six endpoints, at the same 10 req/min, 100 req/day and 3,000 units/month. An EVM call from a trial key costs one unit, the same as a Solana one. Paid plans were already all-chains and are unchanged.

2026-08-28 · Added · MCP connector at /mcp

The /v1 surface is now also reachable over the Model Context Protocol, so Claude, ChatGPT and other MCP clients can run scans in-conversation. Fifteen read-only tools, metered against your existing key exactly like REST calls. Nothing about the REST API changed. See MCP Connector.

2026-08-28 · Breaking · /v1/trending returns a named array

The feed is answered as a JSON array, and the endpoint used to spread it into the response envelope. That scattered the tokens across numeric keys — "0", "1", "2" … — next to timestamp and poweredBy, so reading the list meant subtracting the envelope and collecting whatever was left. The tokens now arrive in a trending array.

// before
{ "timestamp": "…", "0": { "symbol": "EX" }, "1": { "symbol": "FOO" }, "poweredBy": "DeFade.org" }

// after
{ "timestamp": "…", "trending": [ { "symbol": "EX" }, { "symbol": "FOO" } ], "poweredBy": "DeFade.org" }

If you read numeric keys, you must change your code. Anywhere you filtered the envelope out and took the rest — Object.entries(res).filter(([k]) => !isNaN(k)) or similar — becomes res.trending. An error response is unaffected: a failure still puts error at the top level rather than inside trending.

2026-08-28 · Added · /v1/dev-tracker says where the dev wallet came from

Two new fields. creatorSource names the signal that identified the wallet, and creatorInferred is true when that signal does not identify a person — a launchpad stamps one authority across every token it mints, so an authority-derived address is a guess, not a dev. Treat an inferred wallet's position as unconfirmed. Existing fields are unchanged.

2026-08-28 · Fixed · /v1/dev-tracker lastActivity is populated

It had always been null. It is now the unix timestamp of the dev's most recent move of the token, across every bucket the endpoint tracks, and null only when the wallet has never moved it.

2026-08-28 · Docs · response schemas rewritten against the endpoints

No API behaviour changed here, but the reference on this page did. Every response sample used to open with a "mint" key that no endpoint returns — responses carry token, timestamp and poweredBy — and several field lists named fields that do not exist (/v1/analyze listed rugScore and riskLevel; /v1/holders listed top10Pct; /v1/whales, /v1/bundles and /v1/snipers listed counts that live inside summary). Every entry has been rewritten against the response its endpoint actually sends. If you built against the old schemas and something never worked, this is why.

Older changes

This log starts on 2026-08-28. Earlier changes were not recorded. For anything before that, the endpoint reference above describes current behaviour.