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 or Robinhood Chain 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 and Robinhood Chain.

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 all four chains 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 Solana only.

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 23 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

23 endpoints covering every angle of on-chain risk. Click any endpoint to expand full details, parameters, and response schema. Every paid plan unlocks all 23 endpoints — plans differ on included volume, rate limit and chains. The second badge shows chain support: 20 run on every chain, bundles and fee-fingerprint are 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. Three exceptions: /v1/holder-overlap takes several mints so it carries mints instead of token; /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, four chains. 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 variant, not of the endpoint. Every plan ships in two variants with an identical endpoint list:

Requesting a chain your plan doesn't cover returns 403. 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

20 of the 23 endpoints run on every chain. Two are Solana-only:

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

Pricing & Plans

Start free. Scale as you grow. Pro and Enterprise unlock every endpoint.

What each plan includes

Every paid plan includes all 23 endpoints on every chain — plans differ by monthly request volume, rate limits and support. Expensive deep-analysis calls are metered in request units, so heavy endpoints draw more units per call. The free tier covers 6 endpoints. Calling past your plan returns 403 or 402 with upgrade instructions.

Every plan comes in two variants. The Solana variant answers for Solana tokens only. The All-Chains variant answers the same endpoints on Ethereum, Base and Robinhood Chain as well — the endpoint list is identical, only the chains differ. See Chains.

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.02).

How It Works

1. Purchase a credit pack via the dashboard 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.

Credit Packs

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.02",
    "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.02). 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

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 Solana.

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-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.