AgentMarketMCP / SKILL 资产档案馆

目录 / Pre-trade rug checks for pump.fun and Robinhood Chain memecoins

MCP 鉴权未知 未评级 已上架

Pre-trade rug checks for pump.fun and Robinhood Chain memecoins

Pre-trade rug checks for new pump.fun and Robinhood Chain memecoins: free coarse verdict per token (token_check), paid detail per call in USDC via x402 or a prepaid key. Calibrated rug and graduation odds, holders, creator and deployer records and sell checks from our own capture of public on-chain data.

该来源不提供完整文件导出（国内平台多为平台内托管），仅存元数据与原链

接入信息

传输形态
http
鉴权方式
鉴权未知
端点
https://loophole-tape--loopholetape.run.tools
鉴权方式未标注，请核对官方文档后再接入——不要直接使用以下片段
{
  "mcpServers": {
    "Pre-trade rug checks for pump.fun and Robinhood Chain memecoins": {
      "url": "https://loophole-tape--loopholetape.run.tools"
    }
  }
}

能力清单

工具说明
token_checkFree. Pre-trade rug check for one new memecoin: a pump.fun mint (a mint or a pump.fun/gmgn/solscan/birdeye link) or a Robinhood Chain pons curve or token address (0x + 40 hex, or its ponsfamily.com/launchpad link). Returns verdict (avoid | caution | no_flags_observed by the fixed public rule, the same word the paid verdict and rhc_curve_card give; null when the token is not covered), reason {code, text} (the first rule that fired), coverage (full | thin | not_covered, with coverage_reason), age_s and next: the paid detail (verdict $0.01 and mint_risk_card $0.025 for pump.fun, rhc_curve_card $0.02 for pons) and the free record page. No odds, holder shares or market figures; no_flags_observed is not a safety verdict. 30 calls per hour per client. Use it first on any token you are about to buy, then pay for the evidence when the word matters.
catalogFree. Start here: every tool with its price in USD, required arguments, what it returns, the x402 payment terms (USDC on Solana mainnet or Base, payTo per network, facilitator) and the label semantics URL. Returns JSON. Use it first to choose a tool and budget; it carries no market data.
healthFree. Feed health: feed_lag_s (seconds between the newest event in our tape and now), is_stale, last Solana slot, mints tracked, counters. Use it before trusting a card's freshness; it carries no per-mint data.
market_regimeFree. pump.fun market regime meter: launches per minute, mayhem share, curve buys/sells per minute, fail share, pool swaps, migrations vs true graduations (curve witnessed >= 84 SOL) in the last hour, rug flags per hour, history totals. No arguments. Returns JSON. Use it to judge the pump.fun market as a whole; not for one mint (use check_pumpfun_risk).
sample_mintFree. One full risk card (the exact paid mint_risk_card shape) for a mint aged >= 300 s with >= 3 buys, delayed. Use it to see every field before paying; the server picks the mint, so it is not a check on yours. No arguments.
radarFree. The covered pump.fun mints under 30 s old ranked by calibrated rug-within-300s probability and the covered mints under 15 min (>= 5 buys) ranked by true-graduation probability, ten each, refreshed every 5 s, each with the paid check URL and tool. The free preview of the paid number. No arguments. Use it to find fresh mints worth a paid check; for a mint you already hold call check_pumpfun_risk.
check_coverageFree. Check full live coverage and <= 5 s feed freshness for one to five pump.fun mints before paying. Returns availability and exact prices. Use it right before a paid check; it returns no risk findings.
watchlist_updatesFree. Initialize a watch cursor or check for new documented risk/lifecycle events for the same one to five mints. Returns availability only; a paid check returns event details and an updated cursor. Cursor lasts 24 h. Poll every 15 s or slower. Use it to watch held mints without paying; buy details only when it reports new events.
check_pumpfun_riskUse right before a swap or while holding one pump.fun memecoin; not for finding new mints (use the free /v1/radar or the $0.001 delta feed, GET /v1/launches/since). Solana token safety check for one pump.fun mint (observations and odds, never a guarantee). Calibrated P(rug within 5 min) for young mints and P(true graduation), validated out of time (/v1/calibration); creator exits, early-wallet selling, curve/pool drains, migration classification, holder concentration and buyer flow. Findings include first-observed times and numeric evidence. Full coverage and feed lag <= 5 s required; stale/unavailable data is unpaid. Optional cursor: no new watched events is unpaid. No flags observed is not a safety guarantee. Exact signed-payment retries recover the original result for 10 min without a new settlement; timestamps identify its age. Each item also carries market (USD price, market cap = price x total supply as pump.fun and DexScreener show it, the curve's SOL liquidity in SOL and USD) and authorities (mint, freeze, metadata; the pump.fun program rule).
check_watchlist_riskUse when you watch two to five pump.fun memecoins and want one payment for all of them; for a single mint the $0.005 single check (GET /v1/check/mint) costs less. One payment checks one to five caller-selected pump.fun mints for observed creator exits, bundle selling, drains and migration state, each with calibrated P(rug within 5 min) and P(true graduation) (/v1/calibration), with compact holder concentration/flow measurements and timestamped evidence. Every mint must have full coverage and feed lag <= 5 s; an unavailable batch is unpaid. Optional cursor: no new watched events is unpaid. Use /v1/check/watch for free update availability. Price is $0.01 total, not per mint. Findings describe observations, not predictions. Exact signed-payment retry cache: 10 minutes. Each item also carries market (USD price, market cap = price x total supply as pump.fun and DexScreener show it, the curve's SOL liquidity in SOL and USD) and authorities (mint, freeze, metadata; the pump.fun program rule).
verdictUse when you need one answer for a Solana memecoin on pump.fun you are about to buy or hold, plus a link to pass on; for the raw evidence use the $0.005 compact check (GET /v1/check/mint), and to find mints use the free /v1/radar. The compact check of one mint as a bounded verdict with a one-line reason, the calibrated P(rug within 5 min) and P(true graduation) exactly as /v1/check/mint publishes them (/v1/calibration), up to three observed flags with first-observed times and evidence, and share_url: a free card page signed at purchase time that anyone can open without paying. The rule is fixed and public (/v1/labels): avoid = a documented rug or close flag observed, or P(rug within 5 min) >= 0.5; caution = P(rug) >= 0.1, concentrated, stalled or mayhem risk label, or odds unavailable; no_flags_observed = none of these, which is not a safety guarantee. P(true graduation) never softens a verdict. Same rules as the compact check: full live coverage and feed lag <= 5 s required; unavailable or stale is unpaid. Exact signed-payment retries recover the original result for 10 min. The verdict also carries the compact check's market (USD price, market cap = price x total supply, curve liquidity) and authorities (the pump.fun program rule), and its free card shows the market cap at purchase. The answer also carries the mint's cohorts block (dev, bundlers, snipers, top-1 and top-10 share, and the holders' reputation across tokens) as context for the reasons; the rule does not read it.
mint_risk_card$0.025 USDC per call. Use when you need every measured field for one pump.fun memecoin (holders, creator, rug flags, calibrated odds), including an older mint outside the live window (thin card); for a quick pre-trade rug check use the $0.005 compact check (GET /v1/check/mint, MCP check_pumpfun_risk). Input: mint (a mint or a pump.fun/gmgn/solscan/birdeye link). Risk card for ONE pump.fun mint, always HTTP 200 for a valid base58 mint. coverage=full when the mint is in our live window: holders (count, top-5 share, HHI, create-slot bundle / insider / creator shares), rug/close flags with first-seen times, curve truth (graduation = curve witnessed >= 84 SOL), demand (unique buyers, buys/sells 60 s, net SOL), the creator's record at launch (no look-ahead), warm-launch (observed creator-funding links) label, exit signals, calibrated P(rug within 5 min) for young mints and P(true graduation). coverage=thin otherwise: our resolved launch record if any + current bonding-curve state and mint / freeze authority from RPC + creator prior. Any Solana SPL mint, not only pump.fun, gets the thin card: mint / freeze authority and the Token-2022 extensions that let someone seize, block or tax holders' tokens (permanent delegate, transfer hook, transfer fee). Every card carries status, risk_label, confidence, a why[] list and market base rates. Nulls carry a reason; nothing is guessed. Every card also carries market (USD price, market cap = price x total supply as pump.fun and DexScreener show it, the curve's SOL liquidity in SOL and USD, the SOL/USD used and its time) and authorities (mint, freeze and metadata mutability: the pump.fun program rule on live mints, read on-chain on thin cards). A full card also carries the cohorts block: the supply held by the dev, bundlers and snipers with their wallets and SOL in and out of the curve, and top-1 and top-10 share (/v1/labels, cohorts), with the holders' reputation across tokens: the share held by known dumpers, repeat bundlers and wallets new to our tape (/v1/labels, reputation). Returns JSON envelope {ok, coverage: full|thin, data{status, risk_label, confidence, why[], curve, market, authorities, demand, holders, exit_signals, creator_prior_at_launch, rug_flags, flags, base_rates, next, cohorts{top1_share, top10_share, shares_complete, dev, bundlers, snipers, reputation{status, known_dumpers_share, repeat_bundlers_share, new_wallets_share, basis}}}, meta{feed_lag_s, is_stale}}.
recent_launches$0.01 USDC per call. Use to screen the new Solana tokens launched on pump.fun in the last hour in one call; to poll continuously use the $0.001 delta feed (GET /v1/launches/since, MCP launches_since), and for one mint the $0.005 rug check. Optional args: limit (1-100, default 50), max_age_s (30-21600, default 3600), exclude_mayhem (default true), min_rs (curve SOL floor), only_alive (drop rug-flagged). Recent pump.fun launches (default: last hour, mayhem excluded, newest first) as compact cards: curve SOL and progress, unique buyers, holder concentration, create-slot bundle/insider/dev shares, the creator's record at launch (launches, grad rate, rug rate; no look-ahead), warm-launch label, rug flags with first-seen times. The funnel for a screener: filter by min_rs / only_alive and then buy full cards for the survivors. Each item also carries market (USD price, market cap = price x total supply as pump.fun and DexScreener show it, the curve's SOL liquidity in SOL and USD) and authorities (mint, freeze, metadata; the pump.fun program rule). Returns JSON envelope with data{count, items[compact cards]}.
recent_rugs$0.02 USDC per call. Use to see which Solana memecoins fired rug or close flags in a recent window and by which mechanism; not a check on a mint you hold (use the $0.005 rug check, GET /v1/check/mint). Optional args: limit (1-200, default 50), window_s (60-21600, default 3600). Rug and close flags fired in the window (newest first), each with its mechanism (creator_sold, bundle_dumped, curve_drained, pool_drained, curve_closed_low, migrate_below_grad), the flag time, the mint's age at the flag, peak and current curve SOL, name/symbol/creator. Use it to review observed risk events and their frequency. Returns JSON envelope with data{count, items[{t, mint, flag, detail, mint_age_at_flag_s, peak_rs_sol, rs_sol, creator}]}.
recent_graduations$0.02 USDC per call. Use to list recent pump.fun memecoin migrations and tell true graduations from below-threshold closes; not a live pre-trade rug check on one mint (use the $0.005 compact check, GET /v1/check/mint). Optional args: limit (1-100, default 50), window_s (60-86400, default 21600). Migrations to PumpSwap in the window (default 6 h), each labelled graduated=true only when we witnessed the curve at >= 84 SOL, otherwise a below-threshold close (mayhem or operator pools). Each item is a compact card with the migrate time, pool, peak curve SOL and the holder/creator labels. Returns JSON envelope with data{count, items[compact cards + migrate_t + graduated]}.
creator_reputation$0.02 USDC per call. Use to judge a new memecoin by its creator's earlier pump.fun launches on Solana (graduated or rugged) before buying; for the launch's own live evidence use the compact check (GET /v1/check/mint) or the full card (GET /v1/mint/{mint}). Input: address (base58 wallet). Creator stats over every launch we have seen from this wallet, counting only outcomes known at request time: n_launches, resolved, graduations witnessed at >= 84 SOL, rugs by drain or dev dump, median seconds to the dev's first sell, total dev buys; the last 25 launches with outcomes; the creator's live mints right now; and whether the wallet was funded in the last 30 min (warm launch). Empty stats (is_first_time=true) for a wallet we never saw launch. Returns JSON envelope with data{creator, stats{n_launches, n_resolved, grad_rate, rug_rate, median_dev_sell_s, is_first_time}, recent_launches[], live_mints[], funded_recently_by}.
wallet_profile$0.02 USDC per call. Use to classify a wallet buying a pump.fun memecoin (insider, latency_bot or skilled) and read its realised PnL when it ranks on our leaderboard; it describes the wallet, not a mint's rug risk (use GET /v1/check/mint). Input: address (base58 wallet). An unranked wallet gets a null class and no PnL. A ranked wallet carries its class and rank with stats (realised PnL in SOL, win rate, positions) from our realised-PnL leaderboard over the pump.fun trades we captured (window and build time in the response); every wallet gets its holdings among the last 3000 mints (token share, first-buy slot, curve SOL now), creator stats if it ever launched, and its recent funding source. Use it to weight the buyers on a curve. Returns JSON envelope with data{wallet, leaderboard{class, rank, stats}, as_creator, live_holdings_recent_mints[], funded_recently_by}.
rhc_regimeFree. Robinhood Chain (chain 4663) pons regime meter: launches per hour, graduations per hour and rate, median launch-to-graduation seconds, curve buys/sells per minute, unique buyers, snipe-tax facts, feed health. No arguments. Use it to gauge Robinhood Chain launch activity as a whole; not for one curve (use rhc_curve_card).
rhc_recent_launches$0.01 USDC per call. Use to screen or poll new pons memecoin launches on Robinhood Chain (4663), optionally ring-shaped ones only; one token's full risk card is GET /v1/rhc/curve/{address}. Not for Solana. Optional args: limit (1-200, default 50), max_age_s (30-21600, default 3600), pair ('any' | 'eth'), only_live (bool), min_buys (int), ring_only (bool), since (unix seconds cursor). Recent pons memecoin launches on Robinhood Chain (chain 4663; default last hour, newest first) as compact structure cards: raised (ETH), progress to the 4.2 ETH graduation, price multiple vs launch (exact curve reserves), the launch's trade fee and creator tax in bps (fees.creator_tax_bps: 0-1000 under the current on-chain cap, chosen by the creator, charged on every buy and sell), snipe-tax activity, holder concentration (top-1 / top-5 / HHI), same-block direct-buy cluster share (matching timing, not proof of coordination), terminal-vs-direct route mix with the terminal router transactions joined to their wallets, inflow (new buyers in the last 2 / 6 s), lifecycle (live / complete / graduated). Every card carries a ring block: the RING SCREEN flags the same-block direct-buy cluster structure our own capture measured (unique_buyers >= 8 and same-block direct-buy cluster share >= 0.5; on pons v2 such a cluster is often the team's own opening bundle, exempt from the snipe tax at launch); ring_only=true returns just those curves, and the response carries the rule with its measured base rates (14.5% of launches, 47% dumped, median 0.37x terminal in the 2026-09-06/07 window) so you can price the flag yourself. Matching timing is not proof of coordination. Filter pair=eth for ETH-paired curves or min_buys for a minimum observed activity count. Poll with since=<next_cursor> to receive only launches you have not seen, oldest first. Each item also carries verdict (avoid / caution / no_flags_observed) and basis, the rule ids of the fixed public rule (LABELS rhc_verdict at /v1/labels) that fired; the curve card gives each reason with its evidence and base rate. Returns JSON envelope with data{count, items[compact structure cards, each with verdict and basis by the public rule], ring_rule} (+ next_cursor, truncated with since).
buy_api_key$2.00 USDC once. Use when your client cannot sign an x402 payment on every call, or to pay many calls (rug checks, launch polls, wallet and creator cards) from one purchase; not needed if your client already pays x402. Each new payment here buys a new $2.00 key. One x402 payment of $2.00 (USDC on Solana or Base; by header, or in a browser with a wallet) returns a key lt_... holding $2.00 of credit. Send it as the X-API-Key header on any paid HTTP route and that route's price is deducted; no x402 client is needed after the purchase (the same header on POST /mcp pays the MCP tools). Free balance: GET /v1/keys/balance with the header. Credit does not expire; the key is a bearer secret. The key activates when the same request settles; the same signed payment retried returns the same key. No arguments.
buy_dataset$5.00 USDC per day file. Use to backtest or train a rug or graduation model on one full UTC day of Solana token launches on pump.fun; not for live decisions (use the compact check or the delta feed). Input: day (UTC, YYYY-MM-DD, from the free HTTP index /v1/datasets). Every pump.fun launch our capture saw on that UTC day (about 15k-35k rows) with creator, dev buy and share, name/symbol/uri, outcomes as our label rules define them (graduated with migration delay, rugged with rug delay, creator first-sell delay, peak and terminal reserve) and the first feature snapshot under 10 s and between 10 and 60 s of age where sampled (dev/insider/bundle shares, creator prior, reserve, buys). Free 200-row sample and schema at /v1/datasets. HTTP returns the parquet bytes; the MCP tool returns a one-hour download URL. The last three days are rebuilt nightly as outcomes settle. Returns a download URL valid for one hour plus rows, bytes and sha256.
launches_since$0.001 USDC per poll. Use when a bot polls for newly launched Solana tokens on pump.fun with their calibrated odds; for a one-off screen of the last hour use GET /v1/launches/recent, and for one mint the $0.005 rug check. The polling feed for bots: every covered launch created after `since` (unix seconds; default the last 60 s, at most the last hour), oldest first, up to 100 per call, each with creator, reserve, buys, buyer inflow, top-5 holder and creator shares, first-observed flags, the calibrated P(rug within 300 s) for young mints and P(true graduation), and the paid check URL. Returns next_cursor to pass back as since. An empty page costs the same call, so poll at the launch rate you need (about 20 launches per minute). Each item also carries its verdict word by the /v1/verdict rule with p_rug_300s and p_true_graduation; no_avoid=1 drops avoid items and min_p_grad keeps items at or above that P(true graduation), and next_cursor still advances past what they drop.
buy_trial_key$0.10 USDC once. Use to try the prepaid-key path with a small budget before the $2.00 key; each new payment here buys a new $0.10 key. The same prepaid key as /v1/keys/new with $0.10 of credit (about twenty $0.005 rug checks or a hundred $0.001 launch polls): one x402 payment, then X-API-Key on any paid HTTP route. For trying the header path with a small agent budget. Free balance: GET /v1/keys/balance. No arguments.
rhc_curve_card$0.02 USDC per call. Use when you hold or are about to trade one pons v2 token on Robinhood Chain and need a verdict by a fixed public rule, its holders, creator tax, deployer record, ring screen and an exact sell check; to find launches use GET /v1/rhc/launches/recent. Not for Solana mints. Input: address (0x-prefixed pons v2 curve or token address on Robinhood Chain). The verdict (avoid / caution / no_flags_observed, the fixed public rule LABELS rhc_verdict at /v1/labels, with basis, reason and up to three reasons carrying their evidence and measured base rate): avoid while a charged buy pays >= 618 bps of snipe tax or when the 3 s holder structure matched the ring rule; caution on a creator tax >= 500 bps, a top holder >= 50%, a deployer with >= 3 earlier launches and no graduation, a curve at <= 50% of its peak price 30 min after launch without graduating, a missing or pending 3 s snapshot, or a completed or graduated curve. deployer_record: the deployer's earlier launches on our tape, how many graduated or matched the ring rule at 3 s, the median peak and terminal multiples. sell_check: buy and sell tax in bps, the exact quote for selling 1% of supply and a 0.01 ETH round trip in bps from the recorded reserves (graduated tokens: the pool's taxes, no quote). Full structure card for ONE pons v2 curve on Robinhood Chain, addressed by curve or token address (0x…): launch facts (block, deployer, pair token, graduation threshold), raised / progress / price multiple vs launch (exact curve reserves, ETH-paired curves), the launch's trade fee and creator tax in bps (fees block; the creator tax is charged on every buy and sell and is invisible to three-word event parsers), snipe-tax activity, holder ledger concentration (top-1 / top-5 / HHI / deployer share), same-block direct-buy cluster share and wallets, max direct buys in one 100 ms block, terminal-vs-direct route mix with terminal holdings share, flow (buys / sells / unique buyers / new buyers in the last 2 and 6 s / last trade age / volumes), lifecycle (completed / graduated blocks and delays, refunds), the trade_cost block (for a 0.01 and a 0.05 ETH clip at the curve's reserves now, exact with fee and creator tax on both legs and own impact: fill price vs marginal, the immediate round trip, and the price rise from now needed to break even), and the ring block: the same-block direct-buy cluster screen (unique_buyers >= 8 and same-block direct-buy cluster share >= 0.5) our own capture measured at 14.5% of launches, 47% dumped, median 0.37x terminal; matching timing is not proof of coordination, and on pons v2 such a cluster is often the team's own opening bundle, exempt from the snipe tax at launch. coverage=full for curves launched inside our event window (last ~2 h, trades observed from block 0); thin = launch facts + lifecycle only, with a reason. Always 200 for a valid address. Returns JSON envelope with data{curve, token, status, coverage, raised, snipe_tax, structure, flow, lifecycle, verdict, basis, reason, reasons, deployer_record, sell_check}.
rhc_curve_trades$0.02 USDC per page. Use when you index or price a pons curve and need the reserves after each trade, which the deployed curves do not emit; check your own numbers first on the free sample GET /v1/rhc/sample/trades?address=. Input: address (0x pons v2 curve or token), since (optional: optional start, exclusive: next_cursor 'block:log_index' of the previous page, a block number, or unix seconds (values >= 1e9); omitted = from the curve's first trade), limit (1-500, default 100). Reserves of one Robinhood Chain memecoin curve rebuilt to the wei with the exact four-word pons v2 model from its public events in our own capture. Per buy, sell and fee-sweep buyback in block order: amounts, fee, snipe and creator tax, Q and T after it (getReserves()), price Q/T, multiple vs launch, share of the 4.2 ETH graduation raised, a check against the prior state, next_cursor. ETH-paired curves up to 90 min old. Returns a JSON envelope with data{curve, fees, model, items[block, log_index, side, amounts, reserves_after{Q, T, real_quote}, price_after, price_multiple, raised_fraction, check], next_cursor, more, replay}.
launches_screened$0.01 USDC per call. Use when a screener wants the newest Solana memecoins on pump.fun already screened in one call, instead of a discovery call plus one rug check per token; for one mint use the $0.01 verdict (GET /v1/verdict). The newest covered pump.fun launches (default the last 15 min; mayhem-class launches left out, as on the radar) whose verdict is not avoid under the fixed public rule of /v1/verdict (/v1/labels), ranked by calibrated P(true graduation) (/v1/calibration), highest first, up to 50 per call. Each item: the verdict word (caution or no_flags_observed), the one-line reason and up to three reasons, P(true graduation), P(rug within 5 min) for mints under 30 s, age, curve SOL, buys and links to the verdict, the rug check and the full card; scanned and avoid_skipped count what was read and left out. Feed lag <= 5 s required: a stale feed or an empty screen is refused unpaid. no_flags_observed is not a safety guarantee. Each item also carries market (USD price, market cap = price x total supply as pump.fun and DexScreener show it, the curve's SOL liquidity in SOL and USD) and authorities (mint, freeze, metadata; the pump.fun program rule).
check_batch_risk$0.04 USDC per call. Use when a screener checks a list of up to 25 pump.fun memecoins in one call and some may be outside the live window; at 21 to 25 mints it costs less per mint than the five-mint watchlist check (GET /v1/check/watchlist, $0.01), below that the watchlist costs less. One payment checks one to 25 caller-selected pump.fun mints. Each covered mint gets the compact check's item (observed creator exits, bundle selling, drains, migration state, calibrated P(rug within 5 min) for young mints and P(true graduation) (/v1/calibration), holder concentration, buyer flow and timestamped evidence) plus its verdict word by the /v1/verdict rule; a mint outside our live window is listed with coverage unavailable instead of refusing the batch. Price is $0.04 total, charged when at least one mint is covered and the feed lag is <= 5 s; a batch with none covered, more than 25 mints, a malformed or a repeated mint is refused unpaid. No cursor (the watchlist check watches up to five). No flags observed is not a safety guarantee. Each item also carries market (USD price, market cap = price x total supply as pump.fun and DexScreener show it, the curve's SOL liquidity in SOL and USD) and authorities (mint, freeze, metadata; the pump.fun program rule).
mint_holders$0.01 USDC per call. Use when you need who holds one pump.fun memecoin right now, its largest wallets and the creator's and create-slot buyers' shares; for who bought and sold trade by trade use GET /v1/mint/{mint}/flow. Input: mint (a mint or a pump.fun/gmgn/solscan/birdeye link), limit (1-100, default 50). Up to 100 holders of one covered pump.fun mint, largest first, from our own per-wallet ledger of its bonding-curve trades: rank, wallet, share of supply, tokens, first-buy slot and time, last trade time, how the first tokens moved, buy and sell counts, and the labels we observe (dev = the creator, bundle = first tokens in the create slot or the next one, mayhem_agent; insider, latency_bot or skilled when the wallet is ranked on our pump.fun leaderboard, otherwise none). The concentration block carries the holder count, top-5 and top-10 share, HHI and the dev, bundle and insider shares the compact check reports. A cohorts block groups the supply by launch role: dev (the creator and the wallets our funding capture saw it fund), bundlers (first tokens in the create slot or the next), snipers (2-5 slots after it), each with its share of supply, wallet count, SOL in and out of the curve and its largest wallets, plus top-1 and top-10 share; each holder row names its cohorts. Labels are observations, not a verdict on a wallet. Full live coverage and feed lag <= 5 s required; an uncovered mint or a stale feed is refused unpaid. After a migration the ledger stops at the curve. The cohorts block also carries the holders' reputation across tokens: the share of supply held now by known dumpers (wallets that sold within 60 s of their first buy on 3 or more other mints), by repeat bundlers (in the create-slot bundle on 3 or more other mints) and by wallets new to our tape, from our own trade tape since 2026-09-27T00:18:34Z; each holder row carries its history on other mints (mints, bundled, quick sells, settled, rugged, graduated). Returns a JSON envelope with data{mint, n_holders, concentration, cohorts{top1_share, top10_share, union_share, shares_complete, unbooked_sol, dev, bundlers, snipers, fresh_wallets, omitted, reputation{status, known_dumpers_share, repeat_bundlers_share, new_wallets_share, basis}}, holders[rank, wallet, balance_share, tokens, first_buy_slot, first_buy_at, last_trade_at, route, buys, sells, labels, wallet_class, cohorts, history{mints, bundled, quick_sells, settled, rugged, graduated}], leaderboard, tape}.
mint_flow$0.01 USDC per page. Use when you need who bought and sold one pump.fun memecoin, trade by trade, or to poll its new trades with a cursor; for who holds it now use GET /v1/mint/{mint}/holders. Input: mint (a mint or a pump.fun/gmgn/solscan/birdeye link), since (optional: optional start, exclusive: next_cursor 'slot:index' of the previous page, a slot number, or unix seconds (values >= 1e9); omitted = from the launch), limit (1-500, default 100). Every bonding-curve buy and sell of one covered pump.fun mint from our own capture, in slot order, up to 500 per page: time, slot, index in the slot, transaction signature, wallet, side, SOL, tokens, how the tokens moved, whether it was the wallet's first buy, the wallet's label (dev, bundle, mayhem_agent, or insider, latency_bot or skilled when ranked on our leaderboard) and the running net SOL the curve has taken in since launch. A summary covers the last 60 s and 5 min: trades, unique buyers and sellers, buy, sell and net SOL, first buys, and the largest buyer's and seller's share of that SOL. A demand block (wash trading vs organic volume, from launch) splits the buy SOL by wallet label and gives the share the same wallets sold back and the share bought in crowded slots, and the holders answer's cohorts block (dev, bundlers, snipers, top-1 and top-10 share, the holders' reputation across tokens) rides on every page. Pass next_cursor back as since (a slot:index cursor, a slot or unix seconds); no trade after since, an uncovered mint or a stale feed is refused unpaid. Full live coverage and feed lag <= 5 s required. Returns a JSON envelope with data{mint, items[t, slot, index, sig, wallet, side, sol, tokens, route, is_first_buy, wallet_class, running_net_sol], next_cursor, more, summary{last_60s, last_300s}, demand{buy_share_by_class, round_trip_share, crowded_slot_buy_share}, cohorts{top1_share, top10_share, shares_complete, dev, bundlers, snipers, reputation}, tape}.
mint_outcome$0.001 USDC per call. Use when you grade your own rug or graduation calls or backtest a signal on pump.fun memecoins and need outcome labels you did not write yourself, by a fixed public rule; for a live pre-trade rug check use GET /v1/check/mint ($0.005). Input: mint (any pump.fun mint, a mint or a pump.fun/gmgn/solscan/birdeye link). The outcome of one pump.fun launch from our own capture: launch time and age now, whether it rugged by the public rule (a drain from a peak of at least 5 SOL, or a creator dump) and when, whether that happened within 300 s of launch, whether it truly graduated and when it migrated, the creator's first sell, peak and last curve SOL, the mayhem flag, whether each label is settled (resolved) and the rule version. No probabilities and no opinions. A mint we never saw answers known:false and is charged like any answer: not being in our capture is itself the result. Labels settle when our capture closes the curve path, about an hour after it goes quiet (94% of launches are settled 2 to 3 h after launch); until then they read null, never a provisional false. A malformed mint is refused unpaid. Returns a JSON envelope with data{mint, known, source, t0, launched_at, age_at_query_s, creator, mayhem, graduated, migrate_dt_s, migrate_at, rugged, rug_dt_s, rug_at, rugged_within_300s, dev_first_sell_dt_s, peak_rs, terminal_rs, resolved, resolution, label_rule_version}.
mint_outcome_batch$0.01 USDC per call, whatever the answers. Use when you grade a list of your own rug or graduation calls or backtest a signal on pump.fun memecoins; for one mint the $0.001 single lookup costs less. Input: mints (an array of one to 40 distinct pump.fun mints, each a mint or a pump.fun/gmgn/solscan/birdeye link). One payment returns the outcome labels of one to 40 caller-selected pump.fun mints in the order asked with the fields and the fixed public rule of the single lookup GET /v1/outcome/{mint} and is charged once whatever the answers. Each item: rugged by the public rule and when, rugged within 300 s of launch, true graduation and migration time, the creator's first sell, peak and last curve SOL, the mayhem flag, whether each label is settled (resolved) and the rule version. A mint we never saw answers known:false. More than 40, a malformed or a repeated mint is refused unpaid. No probabilities and no opinions. Returns a JSON envelope with data{count, n_known, n_resolved, items[the single tool's fields, in the order asked], rule}.
subscribe_alerts$0.10 USDC once, for 30 days. Use when a Discord or Telegram room wants new pump.fun memecoins with high graduation odds, true graduations, avoid flips or Robinhood Chain ring flags posted to it without running a server; to poll from code use GET /v1/launches/since ($0.001). Input: destination (a Discord webhook URL or telegram:<bot_token>:<chat_id>), kinds (array of graduation_odds, ring_flags, graduations, avoid_flips), optional min_p_grad, max_age_s, pumpfun_only, rhc_only, label. One payment registers your room's own delivery endpoint for 30 days: a Discord webhook URL, or telegram:<bot_token>:<chat_id> for a Telegram bot you own; any other host is refused unpaid. A test message is posted first and the payment settles when it arrives; a failed test is unpaid. Then every 60 s each new item of the kinds you pick is posted as one plain-text message ending with its public record and paid card links: graduation_odds and graduations are the items of our free Atom feeds (5 minutes delayed), ring_flags the Robinhood Chain pons ring-structure flags, avoid_flips a published graduation candidate whose verdict turns avoid. Filters min_p_grad, max_age_s, pumpfun_only, rhc_only; at most 20 messages an hour and 200 a day. The endpoint is stored encrypted and never echoed or logged: POST it in the JSON body. POST, or GET with the X-Alert-Destination header, is the same purchase. Unsubscribe with the link in the answer. Returns a JSON envelope with data{subscription_id, status, kinds, filters, label, destination_kind, test_delivery, registered_at, expires_at, unsubscribe_url, delivery}.
纠错与举报（发现条目失效、署名有误或涉及侵权？）
提交举报 / 纠错

侵权举报经核验成立后，我们会即时下线该条目并删除已存的内容副本。