Madeonsol

mcp-server-madeonsol

Agent Intelligence Gateway (new in 4.1.0, opt-in). Set MADEONSOL_AGENT_GATEWAY_ENABLED=on together with a paid (PRO or higher) MADEONSOL_API_KEY to add six research tools fixed to Solana: discover_opportunities, evaluate_token, inspect_wallet, inspect_deployer, evaluate_signal and changes_since. They call POST /api/v1/agent-gateway/actions with your key, count against your normal quota and never sign or pay an x402 request. Answers carry per-source evidence and an explicit partial status when a source is limited. changes_since replays seven curated KOL/deployer event families, not every swap. Without the opt-in the tool inventory is unchanged. A hosted endpoint is also available at https://madeonsol.com/api/agent-gateway/mcp (Streamable HTTP, Authorization: Bearer msk_…); it does not implement MCP OAuth, so OAuth-only connectors cannot use it. MCP is how an agent invokes tools, not a billing plan. See the Gateway contract.

The hosted /api/agent-gateway/mcp transport uses per-request account keys and custom Authorization headers. It does not implement MCP OAuth; do not expose this package's private loopback HTTP adapter as a public service.

Six-family early-stream expansion (#457, not activated): the managed earlyStream() client, private-list controls and token/wallet helpers are implemented in the madeonsol-x402 TypeScript SDK. This package does not gain that managed client or new MCP/plugin actions from this PR. Existing sniper compatibility is ULTRA+ and deploy-only. See the release-candidate wire contract for raw WebSocket integration; publication/version parity remains a release gate.

⚡ Install via Smithery · 🤖 Use in Claude Desktop · 🖱️ Use in Cursor · 📚 API docs · 💰 Free API key · 🔎 On Glama

MCP server for MadeOnSol Solana KOL intelligence API. Use from Claude Desktop, Cursor, or any MCP-compatible client.

Real-time Solana trading intelligence: track 2,000+ KOL wallets with <3s latency on paid keys and x402 pay-per-call (free-tier live feeds are 5-min delayed), score 85K+ Pump.fun deployers, surface deshred deploy signals ~500ms before on-chain confirmation, detect multi-KOL coordination, surface bundle-cohort holdings (which same-slot wallets still hold a token's supply), verify any wallet's CURRENT on-chain holdings straight from its token accounts, and stream every DEX trade across 9+ programs. Free tier: 200 requests/day across 40+ endpoints (live feeds 5-min delayed) — no signup payment. Get a key at madeonsol.com/pricing.

Server update 2026-10-05/08 (no package change needed): realtime developer activity and USDC/USDT trade sizing. The signed webhook event dev:activity (PRO+) and the ULTRA+ DEX-socket dev_subscribe path deliver dev_sell, dev_buy, dev_token_transfer_out and dev_token_transfer_in (a transfer is never a sell). Transfer detection is now the union of the legacy bounded developer-wallet watch and the broad SPL Token/Token-2022 candidate source for attributed creators while live. transfer_watch_coverage describes only the legacy watch; transfer_sources.broad in the subscribe ack reports broad-source state/gaps. Recovered broad-source rows are REST history only, never retroactive realtime alerts. Missing creator attribution, source gaps and unsupported mixed swap + standalone-transfer cases remain limitations. On dex:trades, a swap paid in USDC or USDT now carries sol_amount = the SOL equivalent of its stable leg (used by dust, min_sol, max_sol) plus the additive fields sol_amount_basis (native_sol | stable_quote_equivalent | stable_quote_unconverted) and stable_quote; stable_quote_unconverted means sol_amount 0 (size unknown). Details: changelog.

Server update 2026-10-04 (no package change needed): copy-trade rules follow any valid source wallet. source_wallets no longer have to be tracked KOL wallets: any valid Solana wallet fires, KOL membership is optional enrichment, and copy-trade sources do not use Wallet Tracker quota. Each rule reports source_admission (any_wallet) and operational_state (eligible, or an infrastructure state monitoring_pending / monitoring_unavailable / source_capacity_unavailable). source_wallets_tracked / source_wallets_untracked and the untracked_source_wallets warning are legacy fields, still filled. This supersedes the "signals fire only for tracked KOL wallets" wording in older notes below. Limits are unchanged: PRO 3 rules × 5 wallets, ULTRA 20 × 50, BUSINESS 100 × 250.

Deployer activity timeline (expanded 2026-10-08). madeonsol_deployer_activity binds GET /deployer-hunter/{wallet}/activity (PRO+, keyed msk_ API only): one newest-first timeline containing launches, dev_buy, dev_sell, dev_token_transfer_out, dev_token_transfer_in, creator transfers, fee claims, funding in and capital out. Persisted realtime rows can include below-floor trades; recovered transfer rows can carry recovered, recovered_at, late_classified and counterparty_count. Read the per-family coverage/retention before interpreting an empty range; PRO responses carry no identity block or fee-payer address.

New in 4.2.0: bundles over time, bundled-now share, every KOL trade on a token (108 tools total). Three new tools, keyed msk_ API only (no x402 route). madeonsol_token_bundles (GET /tokens/{mint}/bundles) lists every coordinated buy cluster on a token, the launch bundle AND clusters that form later, each with what it still holds and, for clusters the server follows, its exit progress (exit: sold share, wallets fully out, realized SOL). madeonsol_token_bundle_share (GET /tokens/{mint}/bundle-share) gives one figure, the share of supply held right now by every bundle wallet; it is null with a reason unless every wallet was read, never a guessed number. madeonsol_kol_token_trades (GET /kol/tokens/{mint}/trades) returns every stored tracked-KOL trade on one token, newest first, keyset paged. New opt-ins on existing tools: madeonsol_token_cap_table (limit, verify_current_balances, include_scout_scores), madeonsol_token_buyer_quality and madeonsol_token_bundle (include_balances), madeonsol_token_holders (include_wallet_flags). Additive only.

New in 3.3.0: token lock provenance. Tool descriptions: Token lock rows carry provider (identity verified | compatible | unverified; lock_url always null on Solana, never constructed), explorer (Solana Explorer links), price_usd, seconds_until_end, seconds_until_next_unlock and, for Bonfida, the tranche schedule (server 2026-10-02). Additive only. madeonsol_token_locks_feed accepts cursor (strict keyset paging).

New in 3.2.0: paid tool calls recover a lost answer instead of paying again (PAY-05). In x402 (keyless) mode a paid call whose answer is lost or pending is re-sent with the SAME proof and a payer-signed PAYMENT-RECOVERY header (bounded), and returns the server's stored answer. Tool results carry _x402_payment provenance (payment id, original/deferred, live/stored); a payment that cannot be completed returns a coded x402_payment_error that says not to pay again. A recovery retry never uses the X402_MAX_* budget. Against a server that does not offer recovery (older, or with recovery switched off) the result is the previous behaviour: a re-presented proof ends in the 409 replay_detected and is surfaced, never re-paid. No tool added or removed. API-key users: no change.

New in 3.1.1: tool descriptions match the API. madeonsol_token_risk and madeonsol_tokens_batch_risk describe risk evidence for your own policy, not a verdict. madeonsol_deployer_profile names the real response: is_deployer, the nested deployer object (total_tokens_deployed, total_bonded, ...), pump_stats, pump_tokens, launchpad_tokens; an untracked wallet returns is_deployer: false and deployer: null. No tool added or removed.

New in 3.1.0 — copy-trade and Wallet Tracker tools match the API. madeonsol_copytrade_create / _update accept up to 250 source_wallets (the BUSINESS per-rule limit; before, the tool refused anything over 50 before the server could answer). The server still enforces your own tier's limit (PRO 5, ULTRA 50, BUSINESS 250). Create, update and madeonsol_copytrade_signals gain the market-cap band min_mc_usd / max_mc_usd. The only_action description now states the real default (buy), and the tool descriptions say that signals fire only for tracked KOL wallets. madeonsol_wallet_tracker_trades gains order (slot | block_time) and the before_slot cursor, and its action filter is buy | sell only: transfer_in / transfer_out were always rejected by the API with 400. Use event_type: "transfer" for transfers. madeonsol_copytrade_update documents that a PATCH which sets a webhook_url on a rule without a signing secret returns webhook_secret once, and the copy-trade tools describe the source_wallets_untracked / warnings[] fields newer servers return. madeonsol_test_webhook gains an optional event (which subscribed event to sample).

New in 3.0.0 — BREAKING for x402 (keyless) mode only: five env vars are now required and startup FAILS instead of silently degrading (security fix, SDK-01). Set X402_PAY_TO, X402_FEE_PAYER, X402_MAX_AMOUNT_ATOMIC, X402_MAX_TOTAL_AMOUNT_ATOMIC and SVM_RPC_URL alongside SVM_PRIVATE_KEY. Before, keyless mode signed whatever Solana USDC amount, recipient and fee payer a 402 challenge asked for. Now every challenge is checked BEFORE signing against a trusted merchant payTo, a trusted facilitator feePayer (which must differ from your wallet), the USDC mint, solana:5eykt… mainnet, the exact scheme, a per-call cap and a lifetime cap. Use the canonical values in the keyless section below; caps must be at least 20000 (0.02 USDC) per call to reach every endpoint. The budget is per client instance / process: not wallet-wide, not shared between processes, reset on a new instance or restart. Keyless requires the base URL exactly https://madeonsol.com. API-key (msk_) users: no change, no new config. HTTP mode still refuses wallet signers (SEC-02, unchanged).

New in 2.0.0 — BREAKING: HTTP mode now requires a separate token (security fix, SEC-02). If you run this server with MCP_TRANSPORT=http, you must now also set MCP_HTTP_TOKEN (a random secret you generate) and send it as Authorization: Bearer <token> on every request, including GET /health and the server-card endpoint — previously, anything that could reach the bound port could call every tool using the operator's own API key with no authentication at all. HTTP mode is now hard-restricted to literal loopback (127.0.0.1 / ::1), rejects Origin/X-Forwarded-* headers and duplicate Authorization/Host headers outright, exposes only POST /mcp plus the two GET routes, and refuses to start if a wallet/payment signer is configured — HTTP mode can never carry a payer key. If you use the default stdio transport (Claude Desktop, Cursor, most MCP clients), nothing changes — no action needed. This is a single shared-operator-token fix, not a new multi-user or OAuth system; each HTTP caller still shares the operator's own MadeOnSol API key. Full writeup: docs/audit/SEC02_PRIVATE_HTTP_MCP.md.

New in 1.27.1 — the server now reports MCP instructions. The initialize response's instructions field (operational guidance for the calling agent — distinct from this README/package description) was never set; directories that introspect the live server (Glama) reported "no recorded MCP instructions." No new tools; still 104 total.

New in 1.27.0 — top traders, sniper watchlist management, and two update tools (104 tools total at the time). Six additions found by an internal agentic-infra coverage audit. madeonsol_token_top_traders (GET /tokens/{mint}/top-traders, PRO/ULTRA) ranks a token's wallets by realized PnL or ROI, enriched with KOL/alpha-wallet identity — this endpoint already existed on the REST API and x402 rail but had no MCP tool. madeonsol_sniper_watchlist_list / _add / _remove (PRO+/ULTRA) manage your custom sniper-deploy watchlist (madeonsol_sniper_recent(watchlist: true) narrows to it) — previously only reachable via raw HTTP. madeonsol_update_webhook (PATCH) changes a webhook's URL, events, or active state without deleting and recreating it. madeonsol_wallet_tracker_relabel (PATCH) renames or clears a tracked wallet's label.

New in 1.26.0 — deployer reputation as-of a date, and creator-fee rewards. Two new tools (PRO+, keyed API only — no x402 route). binds : the deployer's reputation exactly as it stood on (default today, UTC) — the latest write-on-change snapshot at or before it, so an agent backtests without look-ahead bias. can predate (write-on-change); marks that. No snapshot at or before → — nothing is ever synthesized. must be ≥ 2026-04-07 and not in the future. binds : pump.fun creator-fee rewards, answered two ways that are never merged — (what actually reached the wallet: direct vault claims kept 90 days, social-handle claims, shareholder payouts on token) and (every payout on the tokens it , split / + ). Every money field is ; is (never a silent 0) when a SOL amount exists and no SOL price was available. / (≤10, USD-sorted) show where attributed fees went. Works for non-deployers too (, empty).

New in 1.25.0 — token surges & revivals: momentum fires with the honest half attached. The new madeonsol_tokens_surges tool binds GET /tokens/surges (PRO+, keyed msk_ API only — no x402 route): every token momentum fire, newest first. Two kinds, one row shape. surge — a token < 30 min old whose market cap runs hard against its launch MC, in three tiers that each fire at most once per mint: early (≤10 min, ≥$12k, ≥3× launch), strong (≤30 min, ≥$30k, ≥6× launch and ≥2× the lowest sample of the last 3 min — it is climbing now), breakout (≤2 min, ≥$45k, ≥8×). A tier must be sustained (current tick and a sample ≥10 s older; nothing fires before 20 s of age) — a same-slot bundle marked to $475k at age 1 s is a spike, not a surge. revival — a token with no 1-minute trade candle for ≥24 h that starts trading again, confirmed only by the tape (≥5 buys, ≥$500 buy volume, MC ≥1.5× the pre-dormancy close), never by the price mark; tier is null. Hard gates on both: liquidity ≥$1.5k and ≥2 % of MC, and the MC gained must be paid for by buy volume (a price mark in a spoof pool moves MC on ~$0). Every row carries the burst tape (source candles / wallet_trades; unique_buyers only where the mint is in trade coverage — wallet_data_available:false otherwise, never an inferred zero), kol buyers, the first-20 early_buyers cohort (bundled / sold / sniper wallets), deployer reputation and risk_flags[] (bundled_launch, few_buyers, wash_pattern, thin_liquidity, cold_deployer, sniper_heavy, early_buyers_exiting, sell_pressure, no_tape_trades, no_prior_price, mint_authority_active, transfer_fee — empty means no flag raised, not verified clean). Rows ≥65 min old carry the +1 h outcome; stats=1 prints per-(kind, tier) hit-rates (up_1h_pct, median_peak_multiple, doubled_1h_pct) — out-of-sample by construction. Filters kind, tier, mint, launchpad, , / , , , ; cursors / . Pushed live on the new WS channel (events / ; subscribe filters , , , , / , ) and accepted by as events / with the same filters. The response echoes the live thresholds in .

New in 1.24.1 — stream tokens never expire. madeonsol_stream_token (POST /stream/token) now returns the same token on every call, forever. It stops working only if your subscription lapses or you call the tool with rotate: true to replace it (the previous value keeps working for 60 s). expires_at and the new next_refresh_at are always null (kept for wire compatibility — do not schedule refreshes on them); the response gains rotated (boolean) and lifetime (string). The server never rotates on its own and never sends token_refresh unless you rotated; a 4001 close means "mint again" (lapsed or rotated), never a timer. Prefer Authorization: Bearer <token> on the WebSocket handshake — ?token= still works and is masked in access logs.

New in 1.24.0 — token locks & vesting, upcoming unlocks, and pump.fun creator-fee sharing / claims. Five new tools (all PRO+, keyed msk_ API only — no x402 route). madeonsol_token_locks binds GET /tokens/{mint}/locks: every on-chain lock / vesting contract on a mint (Streamflow, Jupiter Lock, Bonfida vesting) with the schedule, the terms (cancelable_by_sender = the locker can pull it — funds are locked against the recipient, not the locker) and a live-derived view (locked_*, claimable_*, next_unlock) plus a summary with 7d / 30d forward unlock totals. madeonsol_token_locks_feed (GET /tokens/locks) is the cross-token feed of NEW contracts (cursor pagination.next_since, or push on WS channel token:locks), madeonsol_token_unlocks (GET /tokens/unlocks) lists upcoming unlock EVENTS (cliff / period / final / tranche) inside a 1h–90d window sorted by soonest / largest_usd / largest_pct. LP locks are not included — token/vesting locks only. madeonsol_token_fee_shares (GET /tokens/{mint}/fee-shares) decodes a pump.fun coin's on-chain SharingConfig — shareholders with share_bps, is_admin, is_social_pda (fees earmarked for an X identity: social.platform 2 = X, user_id = the numeric platform id, not the handle), redirected_bps, is_default: true = 100% to the creator — plus a distributions rollup and config history; madeonsol_token_fee_claims (GET /tokens/fee-claims) is the fee-event feed (distribution with per-address payouts[], social_claim, shares_created/updated/reset, creator_transferred, creator_claim only when asked via type=), pushed on WS channel token:fee_claims. Fee-event history starts 2026-08-17. All base-unit amounts are digit strings; ui / usd / pct are null when decimals or price are unknown.

New in 1.23.0 — live holder census: exact holder count, labelled holders, and pools that are named, not just excluded. The new madeonsol_token_holders tool binds GET /tokens/{mint}/holders (PRO+): every token account of the mint read from the ledger at confirmed and merged per owner, so concentration.holder_count is EXACT (distinct non-zero owners minus pools / bonding curves / burns) — never a trade-derived estimate; it is null only when the provider refuses the census for a mega-cap, in which case you get the top-20 view and source.census_fallback_reason says so. Each disclosed owner carries our labels (deployer / kol / early_buyer / bundle / bot / dump_cluster — empty means unknown to us, not clean), and excluded[] NAMES what was taken out of the circulating denominator: reason = pool (with dex + pool_address), bonding_curve (pump.fun / LaunchLab), burn, or program_account only when we genuinely cannot attribute the PDA; pool_pct / burned_pct / program_pct split the exclusion. Amounts are raw u64 strings. Disclosure: PRO ranks 1–10, ULTRA 1–50, BUSINESS 1–100 — the maths is tier-independent. Big tokens take 5–30 s upstream: you get 503 holder_scan_in_progress with retry_after_seconds: 20 while the scan finishes into the cache, and the retry is instant.

New in 1.22.0 — two prices on the trade tape, and the right one is now the default. The trade tape now tells you what a trade actually cost. price_sol/price_usd on each trade are THIS trade's executed price — sol_amount / token_amount, reconciling exactly with the amounts on the same row and with the PnL endpoints. Because sol_amount is the wallet's net SOL movement, that is the trader's all-in effective rate: swap fee and any account rent included, not the pool mid. The market-cap tracker's canonical pool price moved to the new market_price_sol/market_price_usd fields — it is sampled once per token per pool update, so every trade in the same slot shares it. Until now price_sol carried that canonical value and disagreed with the row's own amounts by a 7.9% median (p90 ~74%): a stale market price reads low in a pump and high in a dump, so anything you averaged out of the tape inherited the bias instead of cancelling it. Use price_sol for cost basis, fills and PnL; market_price_sol for a per-token series independent of trade size and direction. Both madeonsol_token_trades and madeonsol_wallet_trades carry all four fields, and both tool descriptions spell out which price to use so an agent does not average the wrong one.

New in 1.21.0 — the Deployer Hunter surface completed. Seven new operations that existed on the API but had no SDK binding: madeonsol_deployer_leaderboard, madeonsol_deployer_stats, madeonsol_deployer_profile, madeonsol_deployer_tokens, madeonsol_deployer_alert_stats, madeonsol_deployer_best_tokens and madeonsol_deployer_recent_bonds. Read bonding_rate (lifetime) against recent_bond_rate (rolling) — the gap between them is the signal, not either number alone. runner_rate only means something once labeled_tokens >= 3, and an untracked wallet returns a profile with zeroed counters, not a 404, so check total_deployed before reading a 0% bond rate as a track record. Dependency ranges are now bounded to the versions actually tested (@x402/* ^2.x, @solana/kit ^5.5.1) instead of open-ended >=0.0.1, and the lazily-imported x402 peers are marked optional — a keyed install no longer pulls the whole Solana stack.

New in 1.20.0 — Token depth / price impact + deployer self-activity on risk. New tool madeonsol_token_depth (GET /tokens/{mint}/depth) — per-pool price-impact / slippage: "how much SOL moves this token's price N%", per pool (NOT router-optimal). Pass up to 8 SOL buy sizes (each >0 and ≤10000; default [0.5, 1, 5, 10]); every computable pool returns spot_price_sol, fee_pct, a quotes[] entry per size (size_sol, tokens_out, avg_price_sol, price_impact_pct), and to_move_price — the SOL required to move price 1% / 5% / 10%. Constant-product AMMs are served from stream reserves (source: "stream" with reserves_age_ms); pump.fun/bonk bonding curves from a live read of the curve's virtual reserves (source: "live_rpc"). Pools that can't be priced honestly — concentrated CLMM/Orca/DLMM, Meteora-DBC curves, unclassified models — come back in unsupported_pools[] with a reason (e.g. concentrated_liquidity_depth_not_supported, curve_graduated_use_amm_pool) instead of a wrong number; primary_pool names the deepest computable pool, found: false means no pool with sufficient authoritative data for depth (see unsupported_pools[].reason; tracked pools may still be listed there). PRO/ULTRA only. And madeonsol_token_risk now returns a top-level dev block (deployer self-activity; null when the mint has no deployer-pipeline row): the create-tx self-buy snapshot (buy_sol, buy_tokens, buy_supply_pct), the post-create rollup (bought_tokens_after — catches the same-second-separate-tx dev buy the create snapshot reads as 0 — sold_tokens, sold_sol, first_sell_at/last_sell_at), live on-chain holdings (holdings_tokens, holdings_supply_pct — pump.fun 1B denominator, null elsewhere — wallet_empty: is the dev wallet empty NOW), and transferred_out (tokens left without a sell; null = unknown, never a guess), plus as_of. deployer:alert webhook/WS payloads gain dev_buy_sol + dev_buy_supply_pct.

New in 1.10.3 — Dump-cluster detection. madeonsol_token_buyer_quality breakdown now includes dump_cluster_count (3+ dump-cluster wallets in the first-20 → 94% historical dump rate vs 61% base) and recycled_early_buyer_count. Full breakdown is returned on all tiers. Also: the API now pushes every pump.fun graduation in real time (token:graduations WS channel).

New in 1.10 — Deshred Sniper Alerts. madeonsol_sniper_recent surfaces pump.fun deploys from shred-level data ~500ms before on-chain confirmation. PRO: elite/good deployers. ULTRA: all tiers + custom watchlist. Use sniper:deploys WebSocket or sniper:deploy webhook for live push.

New in 1.9 — Price alerts, scout leaderboard, coordination history. madeonsol_price_alerts_* CRUD (PRO=5, ULTRA=25). madeonsol_scout_leaderboard ranks top scouts by first-touch follow-on rate. madeonsol_coordination_history and madeonsol_peak_history expose the historical record. madeonsol_wallet_stats now returns derived: win_rate, roi, verdict, biggest_miss.

New in 1.8 — Universal Wallet API. madeonsol_wallet_stats, madeonsol_wallet_pnl, madeonsol_wallet_positions, madeonsol_wallet_trades — FIFO cost-basis PnL and cursor-paginated raw trades for any Solana wallet. PRO+. Cache hits don't count against quota.

New in 1.7.0 (2026-05-12) — Two new tools: madeonsol_me (account/quota introspection — read tier, remaining requests, and per-feature usage without parsing rate-limit headers) and madeonsol_tokens_list (PRO+ filtered, sortable token directory — MC band, liquidity floor, primary DEX, authority/safety flags, plus computed 1h volume / MEV-share / MC-change deltas). Token responses now expose velocity / MEV-share fields. Token directory defaults to min_liq=2000 to skip phantom-MC dust — pass min_liq=0 to opt out. /token/{mint} now returns structured 400 errors (code / reason / example / docs) instead of plain strings. Deprecated avg_entry_mc_usd field fully removed from KOL/alpha leaderboards.

New in 4.0.0 (breaking): the sniper tool requires an ULTRA, BUSINESS or ENTERPRISE API key; in keyless (x402) mode it is refused before any payment because the server retired the keyless sniper endpoint on 2026-10-06 (HTTP 410, nothing charged).

Install via Smithery (one line)

Smithery is the easiest path — it writes the config for you and handles the install:

npx -y smithery mcp add madeonsol/solana-kol-intelligence

Smithery prompts for your MADEONSOL_API_KEY (free at madeonsol.com/pricing) and wires up Claude Desktop or your chosen MCP client. Restart the client and ask: "What are KOLs buying right now?"

You can also browse tools from the CLI:

npx -y smithery tool get madeonsol/solana-kol-intelligence madeonsol_kol_feed

Quick start — manual config (10 seconds)

npm install -g mcp-server-madeonsol

Add to claude_desktop_config.json or Cursor MCP settings (free tier at https://madeonsol.com/pricing):

{ "mcpServers": { "madeonsol": { "command": "mcp-server-madeonsol", "env": { "MADEONSOL_API_KEY": "msk_..." } } } }

Restart Claude Desktop and ask: "What are KOLs buying right now?"

AI agent quickstart (x402 / pay-per-call)

Building an autonomous agent? Skip the signup. Configure a funded Solana wallet and an explicit payment budget. Paid tool calls authorize micropayments within that budget over x402 — no API key, no account, no rate-limit dance.

{
  "mcpServers": {
    "madeonsol": {
      "command": "mcp-server-madeonsol",
      "env": {
        "SVM_PRIVATE_KEY": "<base58 solana private key>",
        "X402_PAY_TO": "GLu63pRCYrp4BJu5P5ciYKxgeZFW9c8TJ8jWzK3TB9AR",
        "X402_FEE_PAYER": "2wKupLR9q6wXYppw8Gr2NvWxKBUqm4PPJKkQfoxHDBg4",
        "X402_MAX_AMOUNT_ATOMIC": "20000",
        "X402_MAX_TOTAL_AMOUNT_ATOMIC": "1000000",
        "SVM_RPC_URL": "https://<your-trusted-solana-rpc>"
      }
    }
  }
}

How it works:

• The wallet behind SVM_PRIVATE_KEY settles each request as a USDC micropayment on Solana (~$0.005–$0.02 per call, settled on-chain). No subscription; the configured authorization budget bounds spending.

• Read /api/x402 for the current keyless catalog and prices. Sniper is API-key only.

• The free madeonsol_discovery tool needs no auth and returns every endpoint with its exact per-call price — call it first to see what each tool costs.

• Install the x402 peer deps alongside the server (only required for this mode):

  npm install -g mcp-server-madeonsol @x402/fetch @x402/svm @x402/core @solana/kit @scure/base
  

Data only. MadeOnSol returns trading intelligence — it never trades, signs swaps, or takes custody of funds. The only thing your wallet ever pays for is the per-call data fee.

Prefer a fixed monthly bill, free tier, or no wallet? Use the developer path below.

Required payment policy (breaking keyless upgrade)

Keyless Solana payments require an explicit trusted merchant, facilitator and authorization budget. API-key mode is unchanged and takes precedence over a configured wallet.

Only exact payments in mainnet USDC are permitted. Set the two addresses from your trusted operator configuration, independently of a server challenge. SVM_RPC_URL must be your trusted HTTPS RPC; there is no public RPC fallback. The agent wallet cannot also be the facilitator fee payer.

USDC uses 6 decimals: 20000 = 0.02 USDC and 1000000 = 1 USDC. Choose limits that cover the endpoints you intend to use; these examples are not a price guarantee.

Canonical MadeOnSol values (Solana mainnet USDC). Pinned here (GitHub + npm README) so you do not have to take them from a 402:

• merchant payTo / X402_PAY_TO: GLu63pRCYrp4BJu5P5ciYKxgeZFW9c8TJ8jWzK3TB9AR (also shown on https://madeonsol.com/x402 and https://madeonsol.com/.well-known/x402)
• facilitator feePayer / X402_FEE_PAYER: 2wKupLR9q6wXYppw8Gr2NvWxKBUqm4PPJKkQfoxHDBg4. This is the fee payer of PayAI, the third-party facilitator MadeOnSol's Solana rail uses. If PayAI rotates it, keyless calls fail closed (the client refuses to sign) until you update this value; a MadeOnSol release will announce the new one.
• prices: Solana legs are 5000–20000 atomic (0.005–0.02 USDC), so maxAmountAtomic / X402_MAX_AMOUNT_ATOMIC must be at least 20000 to reach every endpoint.

The budget is per client instance / process: not wallet-wide, not shared between processes, reset when a new instance or process starts. Keyless mode requires the base URL exactly https://madeonsol.com.

The allowance is reserved before concurrent calls can approve/sign. An unsigned denial releases it; entering payment creation retains it even if RPC, signing or the paid response fails. It measures authorized attempts, not settled spend. There is no automatic refund or payment replay. A timeout cannot undo a proof already sent.

The allowance is per server process; restarting starts a new allowance. Reuse the running process. Multiple MCP servers or other clients sharing a wallet need an external shared budget. Missing/invalid keyless settings stop startup; wallet signing remains restricted to stdio. The payment attempt timeout defaults to 30 seconds.

Authentication

Two options (in priority order):

v1.0 breaking change: RapidAPI auth (RAPIDAPI_KEY) has been removed. The MadeOnSol RapidAPI marketplace was retired on 2026-04-19. Get a free msk_ key at madeonsol.com/pricing.

Install

npm install -g mcp-server-madeonsol

x402 peer deps (@x402/fetch @x402/svm @x402/core @solana/kit @scure/base) are only needed when using SVM_PRIVATE_KEY.

Configure

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "madeonsol": {
      "command": "mcp-server-madeonsol",
      "env": {
        "MADEONSOL_API_KEY": "msk_your_api_key_here"
      }
    }
  }
}

Cursor

Add to MCP settings with the same command and env vars.

Private HTTP transport (SEC-02)

Stdio remains the default for Claude Desktop, Cursor and other local MCP clients. HTTP now requires an explicit private-operator configuration; previously unauthenticated HTTP launch settings will fail closed.

1. Set MADEONSOL_API_KEY to the operator's msk_ key.
2. Generate a separate random access token, for example node -e "console.log(require('node:crypto').randomBytes(32).toString('base64url'))", and store it as MCP_HTTP_TOKEN. Do not reuse the upstream API key or put either credential in a URL.
3. Set MCP_TRANSPORT=http, HOST=127.0.0.1 (default, or ::1) and optionally PORT (default 3100). Non-loopback bindings, missing credentials and any SVM_PRIVATE_KEY or RHC_PAYER_KEY are refused before startup. Solana wallet/x402 mode remains available through stdio.
4. Connect to http://127.0.0.1:3100/mcp with Authorization: Bearer <MCP_HTTP_TOKEN> on every request, plus the normal MCP Content-Type and Accept headers. Use stdio if the client cannot attach headers. The local token is checked by the MCP adapter; only MADEONSOL_API_KEY is sent upstream.

Only POST /mcp, GET /health and GET /.well-known/mcp/server-card.json are exposed, all authenticated. / and arbitrary paths are no longer MCP endpoints. The adapter is stateless: it does not issue session IDs, rejects supplied Mcp-Session-Id, and returns 405 for GET/DELETE on /mcp. Host must be the selected loopback literal with its port, or localhost with that exact port. Browser Origin headers, forwarded/proxy headers and cross-origin requests are rejected; no CORS access is granted.

Limits: 256 KiB uncompressed JSON bodies, 8 KiB headers, a 10-second body-upload deadline, and 16 active authenticated requests. Oversized or malformed inputs are rejected before tool dispatch. This is not an overall tool-execution deadline; an upstream action already submitted may continue after a disconnect.

Everyone holding the local token acts as the same operator, including access to that operator's mutation tools. This is not a multi-user/OAuth server: do not put it behind a public proxy, share it with untrusted users or expose a funded signer. Separate users require isolated processes/credentials or a future transport that authenticates each principal and maps their own credentials. Restart with a new MCP_HTTP_TOKEN to rotate access.

The Docker image uses the same loopback restriction and requires both environment credentials. Its healthcheck authenticates without putting the token in the URL. It does not support a publicly published Docker port; use stdio or a client in the same trusted network namespace.

Tools

KOL Intelligence

Deployer Hunter

Early sniper observations (ULTRA/BUSINESS/ENTERPRISE)

Pre-confirm pump.fun deploy feed reconstructed from shred-level (deshred) data — launches surface ~500ms before they confirm on-chain. Pro sees elite/good deployers; Ultra sees every tier.

Wallet Tracker

Universal Wallet (new in 1.8 — any wallet, not just curated KOLs, PRO+)

Cached server-side with dynamic TTL (5min / 1h / 24h based on last activity). Cost basis observable only inside the 90-day window.

Alpha Wallet Intelligence

Scored from 1.5M+ early-buyer records (wallets seen in the first 20 buyers of Pump.fun tokens).

Token Quality

Copy-Trade Rules (PRO+)

Server-side rules that fire signals when a source wallet trades. Delivered via webhook (HMAC-signed) and/or WebSocket. Limits: PRO 3 rules × 5 source wallets, ULTRA 20 × 50, BUSINESS 100 × 250 (Enterprise follows Business). The server enforces your tier's limit. Any valid Solana wallet can be a source, KOL or not (server behaviour since 2026-10-04; KOL membership is optional enrichment and copy-trade sources do not use Wallet Tracker quota). Each rule reports source_admission (any_wallet) and operational_state (eligible, or an infrastructure state: monitoring_pending, monitoring_unavailable, source_capacity_unavailable). A source trade older than 10 s by chain time is not executed, and each trade produces at most one signal per rule. only_action defaults to buy. min_mc_usd / max_mc_usd restrict a rule (or the signals query) to a market-cap band on the source trade; when a bound is set, trades with an unknown market cap are dropped.

KOL Coordination Alerts (PRO/ULTRA — v1.1 push signals)

Real-time push alerts when a KOL cluster co-buys the same token. Fires within ~1s (pg_notify push). Delivered via WebSocket (kol:coordination channel, user-scoped) and/or HMAC-signed webhook.

KOL Scout Signal — first KOL touches (new in 1.3)

Every "first KOL buy on a token mint" event. Filterable by scout tier (S/A/B/C from mv_kol_scout_score), KOL winrate, token age, mint suffix.

Backtest: S-tier scouts attract ≥3 follow-on KOLs within 4h ~50% of the time vs ~14% baseline (38d / 491k buys / 72,549 events). Public leaderboard at madeonsol.com/kol/scouts.

Don't poll — push. Median lead time before the second KOL is 12 seconds. WebSocket channel: kol:first_touches (PRO+).

Price Alerts (new in 1.9)

CRUD for token dip/recovery price alerts. Fires when a token's market cap crosses your threshold. PRO=5 rules, ULTRA=25.

Scout Leaderboard & KOL Consensus (new in 1.9)

Wallet Derived Stats (new in 1.9)

madeonsol_wallet_stats now returns a stats object with derived fields: win_rate (0-1), roi, verdict ("strong" | "profitable" | "neutral" | "losing"), and biggest_miss (token with the highest post-exit gain the wallet missed).

Streaming & Webhooks

General

Tiers

Free tier returns the full REST response shape on 40+ endpoints — real wallets, TX signatures, full precision — with live feeds delayed 5 minutes (delayed responses carry delay/as_of and an X-Data-Delay header). Paid tiers are real-time and unlock webhooks, WebSockets, rule engines, and ULTRA-only data depth; x402 pay-per-call is always real-time. Get a key at madeonsol.com/pricing.

Also Available

License

MIT