DexScreener's free API has 9 endpoints, no historical data, no WebSocket, a 30-result search cap, and a ToS that bans building competing products. If you've hit any of those walls, here's what the MadeOnSol API gives you instead.
DexScreener's API is fine for what it is: a free read layer on their token price data. But if you're building anything serious — a scanner, a trading bot, a copy-trade engine, a deployer alert system — you've probably already hit the wall.
This post is for developers who searched "DexScreener API alternative" because they need something DexScreener can't provide. Here's exactly what that means, endpoint by endpoint.
1. Nine endpoints total, no expansion path. DexScreener's public API covers token pairs by chain/address, search, and a few aggregate views. There's no paid tier that unlocks more endpoints — what you see is what there is. No KOL wallet data, no deployer history, no buyer quality scoring, no copy-trade signals.
2. Zero historical data. Every DexScreener endpoint returns current state. You can't query a token's trading history, a wallet's past performance, or a deployer's bonding track record. If you want trend data, you'd have to poll and store it yourself.
3. No WebSocket streaming. There's no push channel. To react to a new token launch or a KOL buy, you're polling on an interval — which introduces lag (30–60s typical for cron-style polling) and wastes API quota on empty results.
4. Search results capped at 30.
The /search endpoint returns a maximum of 30 results regardless of how many tokens match. For any scanner workflow that filters a broad universe down to your specific criteria, 30 is a meaningless ceiling.
5. Terms of service restrictions. DexScreener's API ToS explicitly restricts building products that compete with their platform. If you're building a tool that includes charting, token discovery, or DEX data display for end users — check the fine print carefully.
None of these are deal-breakers if you're building a quick price check or a personal alert. But if you need the underlying infrastructure to be something you can actually build a product on, you need a different API.
The MadeOnSol API has 80+ REST endpoints plus WebSocket streaming and webhooks, purpose-built around Solana memecoin data. Here's how it maps to the gaps above.
The core token endpoint does what DexScreener does — price, MC, volume — and then layers on the data that matters for memecoin trading decisions:
GET /api/v1/token/{mint}
Authorization: Bearer msk_...
Response includes:
Building a product on Solana data?
Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.
Tools mentioned
Live health scores, average ratings, and direct links on MadeOnSol.
Decentralized Web3 infrastructure with Solana RPC endpoints
Decentralized Solana RPC gateway with auto-failover across a node cluster
Multi-chain RPC provider with free and paid Solana nodes — shared and dedicated endpoints for dApps, bots, and analytics
API marketplace for AI agents — buy and sell APIs with USDC on Solana
Low-latency Solana RPC + data streaming for high-scale dApps, HFT, DeFi, and on-chain analytics.
Get this data via API
Stream real-time KOL trades, PnL rankings, and coordination signals programmatically.
New customers try Pro free for 5 days — card, cancel anytime.
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: "msk_your_key" });
// Real-time KOL trades
const { trades } = await client.kol.feed({ limit: 10, action: "buy" });
// KOL convergence signals
const { tokens } = await client.kol.coordination({ min_kols: 3 });Building a product on Solana data?
MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.
Signals you'd otherwise build
KOL & smart-money flow from 1,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.
Embed it in your product
The Business tier (€400/mo, self-serve) licenses you to display MadeOnSol data inside your own product — 500k calls/day, 10 WS + 5 firehose connections. Enterprise above adds white-label & redistribution rights and custom endpoints.
Evaluate first, commit later
Test everything on a free ULTRA key — no commitment. If it fits, we scope volume or white-label pricing.
Keep reading
Developer Tools
Watch live smart-money trades on Solana and paper-trade them in real time: open a virtual position when a tracked KOL buys, close when they sell, and track PnL from the market-cap multiple. This tutorial walks the open-source kol-copytrade-bot-starter — ~300 lines, one dependency, free API key — and shows how to filter by KOL win rate, deployer tier, and multi-KOL confirmation before risking anything real.
Developer Tools
Understand what Solana APIs are, what types exist, and how developers use them to build trading bots, portfolio trackers, and analytics dashboards. Covers RPC, enhanced APIs, data APIs, and when to use each.
Developer Tools
How to chain three MadeOnSol API endpoints into a token discovery pipeline. Scout leaderboard surfaces early-mover KOLs, consensus confirms conviction, and peak history reveals lifecycle stage — with full TypeScript code for the complete workflow.
Developer Tools
Paste a mint into Telegram, get a scored rug-risk report back in seconds. This tutorial walks the open-source rug-check-telegram-bot starter: zero dependencies, ~150 lines of Node, a free MadeOnSol API key, and a transparent 0–100 score where every point is attributed to a named factor — mint authority, liquidity depth, LP burn, bundled launch, deployer track record.
Developer Tools
Get a Discord embed the moment a proven Solana deployer — one with a real bonding track record on pump.fun or LaunchLab — launches a new token or one of their tokens bonds. This tutorial walks the open-source deployer-alert-discord-bot starter: zero dependencies, ~130 lines, a Discord webhook, and a free MadeOnSol API key.
Developer Tools
You can embed a Solana data API in your app on a standard plan — but the moment you resell the data, expose it as your own feed, or strip the branding, you're in licensing territory most builders discover too late. This guide maps the three usage zones (internal use, user-facing display, redistribution), the questions to ask any data vendor before you build, and what an Enterprise data license actually covers: white-label, bulk export, extended caching, SLA, and dedicated limits.
Enjoyed this article?
Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana tools — free to explore.
Open the KOL Trackerfirst_seen_at + age_seconds — how old the token is from first indexed tradeis_blacklisted + blacklist_category — stablecoins, wrapped assets, flagged rugs automatically excludedFor batch lookups (50 mints per call, one DB round-trip):
POST /api/v1/token/batch
Content-Type: application/json
{ "mints": ["mint1...", "mint2...", "mint3..."] }
The token directory endpoint is what DexScreener search should be:
GET /api/v1/tokens?primary_dex=pumpswap&min_mc=100000&max_mc=2000000&min_liq=5000&authority_revoked=true&max_mev_share_pct=25&mc_change_1h_min_pct=30&limit=100
Twelve server-side filters, five sort options, pagination up to 10,000 rows. You describe the universe you care about; the API returns only tokens that qualify.
| Filter | What it screens |
|---|---|
primary_dex | pumpfun, pumpswap, raydium, raydium_clmm, meteora, orca |
min_mc / max_mc | MC band in USD |
min_liq | minimum pool liquidity in USD |
active_h | drop tokens with no trades in the last N hours |
authority_revoked | requires both mint + freeze authority revoked |
exclude_token2022 | filter out Token-2022 extensions |
min_lp_burnt_pct | LP burn threshold |
min_volume_1h_usd | organic 1h volume (post-filter, MEV-stripped) |
max_mev_share_pct | cap on sandwich/MEV percentage of volume |
mc_change_1h_min/max_pct | 1h MC momentum band |
WebSocket channels replace the polling loop entirely. Events push within ~1s of on-chain confirmation:
// Get a stream token first
const { token, ws_url } = await fetch('/api/v1/stream/token', {
headers: { Authorization: `Bearer ${API_KEY}` }
}).then(r => r.json());
// Connect and subscribe
const ws = new WebSocket(ws_url);
ws.onopen = () => ws.send(JSON.stringify({
type: 'subscribe',
channels: ['kol:trades', 'deployer:alerts']
}));
ws.onmessage = ({ data }) => {
const event = JSON.parse(data);
if (event.channel === 'kol:trades') {
// Real-time KOL trade: wallet, token, sol_amount, action, mc_at_trade
console.log(event.data);
}
};
Available channels: kol:trades, kol:coordination, kol:first_touches, deployer:alerts, price_alert:events, copytrade:signals.
ULTRA tier also unlocks the DEX firehose — every swap across 14 DEX programs (pump.fun, PumpSwap, Raydium AMM/CPMM, Jupiter v6, Orca Whirlpool, Meteora, Launchlab) with targeted filters on token, wallet, DEX, market cap, or token age:
wss://madeonsol.com/ws/v1/dex-stream?token=...
DexScreener has no concept of wallet-level tracking. The MadeOnSol API tracks 1,000+ curated KOL wallets in real-time and exposes the full data layer:
# Live feed of all KOL trades
GET /api/v1/kol/feed?min_kol_winrate=60&action=buy&limit=50
# KOL leaderboard (ranked by PnL, win rate, ROI, profit factor)
GET /api/v1/kol/leaderboard?period=7d&sort=winrate&limit=20
# All KOL activity on a specific token
GET /api/v1/kol/tokens/{mint}
# Tokens being co-bought by 3+ KOLs in the same window (coordination signals)
GET /api/v1/kol/coordination?period=1h&min_kols=3&min_score=70
Every trade is enriched with market_cap_usd_at_trade (MC at the exact moment the swap fired), kol_winrate_7d/30d, kol_strategy_tag, and deployer_tier for the token. For the product-side view of how this data surfaces tokens early, see our guide to the Scout leaderboard, KOL consensus, and peak-history token discovery.
Track which wallets are serial token deployers, their bonding rate, and get pre-confirm alerts when they launch:
# Deployer profile with full history
GET /api/v1/deployer-hunter/{wallet}
# Top deployers ranked by bonding rate
GET /api/v1/deployer-hunter/leaderboard?tier=elite&sort=bonding_rate
# Real-time alerts when tracked deployers launch
GET /api/v1/deployer-hunter/alerts?tier=elite,good&min_kol_buys=2
Alerts include KOL cross-reference — which of our tracked wallets bought the new token and how much SOL.
Before you buy into a token, know whether the early cohort is alpha wallets or bot farms:
# 0-100 buyer quality score for a token's early cohort
GET /api/v1/tokens/{mint}/buyer-quality
# First 10-20 early buyers with win rates, bot confidence, KOL flags
GET /api/v1/tokens/{mint}/cap-table
Response: { score: 78, confidence: "high", signal: "positive", breakdown: { alpha_wallet_count, kol_count, bundle_buyer_count, avg_historical_win_rate, bot_dominated } }
| Capability | DexScreener API | MadeOnSol API |
|---|---|---|
| Token price / MC / volume | ✅ | ✅ |
| Filtered token discovery | ⚠️ 30-result cap | ✅ 12 filters, 10k rows |
| Historical token data | ❌ | ✅ 180d KOL retention |
| KOL wallet tracking | ❌ | ✅ 1,000+ wallets |
| Deployer intelligence | ❌ | ✅ 182k+ deployers |
| Buyer quality scoring | ❌ | ✅ |
| WebSocket streaming | ❌ | ✅ 1s latency |
| Webhook push | ❌ | ✅ HMAC-signed |
| DEX firehose | ❌ | ✅ ULTRA tier |
| Copy-trade signals | ❌ | ✅ PRO/ULTRA |
| Paid tier available | ❌ | ✅ BASIC free → ULTRA |
| ToS: build competing products | ❌ restricted | ✅ no restriction |
| Tier | Price | Calls/day | Key additions |
|---|---|---|---|
| BASIC | Free | 200/day | Full response shape, real wallets, all REST endpoints |
| PRO | €43/mo (≈ $49) | 10,000/day | 3 webhooks, 1 WS connection, copy-trade (3×5), coordination push, price alerts |
| ULTRA | €131/mo (≈ $149) | 100,000/day | DEX firehose, 10 webhooks, 3 WS connections, copy-trade (20×50), linked wallets |
BASIC is genuinely useful — 200 calls/day, full response fidelity (no truncated wallets, no rounded precision), no trial-and-error. A free key takes 30 seconds to generate at /pricing.
import { MadeOnSol } from 'madeonsol';
const client = new MadeOnSol({ apiKey: 'msk_...' });
// Token data with KOL + deployer context
const token = await client.getToken('mint...');
console.log(token.kol_activity, token.deployer, token.mc_change_1h_pct);
// Filtered scanner
const tokens = await client.getTokens({
primary_dex: 'pumpswap',
min_mc: 100_000,
max_mc: 2_000_000,
authority_revoked: true,
mc_change_1h_min_pct: 30,
limit: 100
});
Install: npm install madeonsol. Full reference at /api-docs. Full markdown spec at /api-reference.md (LLM-friendly). There's a Python SDK too — our walkthrough on building a Solana trading research agent with LangChain and the MadeOnSol Python SDK shows it in an AI workflow.
Yes. BASIC is free with 200 calls/day and no payment required. Every REST endpoint is accessible. Webhooks, WebSocket, and the DEX firehose require a paid tier.
No — MadeOnSol is Solana-only and purpose-built for that. If you need multi-chain data, Birdeye or The Graph are better fits.
KOL trade events hit the WebSocket channel within ~1s of on-chain confirmation (CONFIRMED commitment). The DEX firehose runs at PROCESSED commitment (sub-500ms). Sniper pre-confirm alerts (ULTRA) arrive ~500–800ms before chain confirmation via deshred stream.
Yes, without restriction. The ToS does not prohibit building competing or downstream products on top of the API data. For a hands-on starting point, our guide on building Solana trading tools with the MadeOnSol SDK walks through the common patterns.
Solana Tracker and Birdeye focus on price/chart data across all Solana tokens. MadeOnSol's differentiation is the KOL wallet layer (1,000+ curated wallets with 180-day retention), deployer intelligence (182k+ deployers scored by bonding rate), buyer quality scoring, and the copy-trade/coordination signal layer — none of which Solana Tracker or Birdeye expose.
Building a product on top of the data (a bot, terminal, or dashboard) is unrestricted — see the "competing products" answer above. Reselling or exposing the raw feed itself is a separate question with its own rules; our guide to white-label and redistribution rights maps exactly where that line sits, and if the product you're building is specifically a Telegram bot or terminal, the data-layer architecture guide for bot and terminal SaaS covers the endpoint-by-endpoint quota math first.