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. Request an API key

API keys are issued on approval, not self-serve. Request one at defade.org/developers and tell us what you're building. We review the request and email your key, usually within 24 hours. Once you have it, send it with every request in the x-api-key header.

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.rugScore, data.riskLevel);

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['rugScore'], data['riskLevel'])

3. Interpret the results

Every analysis returns a rugScore from 0–100 and a riskLevel classification. Lower scores indicate safer tokens.

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

Keys are issued on approval — request access and we set you up.

Self-serve key generation is no longer available. To get a key, submit a request at defade.org/developers with a short note on what you're building. We review each request and email your key, usually within 24 hours. Your tier (Free, Starter, Pro, or Enterprise) is set when the key is issued and determines your rate limits and which endpoints you can call.

Using your key

Send your key with every request in the x-api-key header (or as an api_key query parameter). Free-tier keys can call the core endpoints (analyze, rug-score, token-price, holders, trending, kol); Starter adds the standard analysis endpoints (16 total), and Pro and Enterprise unlock all 22. See Authentication for details.

API Endpoints

22 endpoints covering every angle of on-chain risk. Click any endpoint to expand full details, parameters, and response schema. The first badge on each row is the cheapest plan that unlocks it — plans are cumulative, so Starter includes every Free endpoint and Pro/Enterprise include all 22. The second badge shows chain support: 20 run on every chain, bundles is Solana-only, and usage reports on your key so it has no chain at all (see Chains).

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 22 endpoints run on every chain. One is 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

Plans are cumulative: every plan includes everything below it. Calling an endpoint your plan doesn't cover returns 403 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.

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.