Mindjack is an MCP server that gives Solana memecoin trading agents rug-risk checks, wallet forensics, and token research tools.
Free tools: sample token report, coverage info, scorecard of measured risk-band hit rates, and credit balance check.
Token risk screening: paid calls like check_token, find_tokens, search_tokens, and test_hypothesis to evaluate danger, find candidates, search the indexed catalogue, and test historical token shapes.
Holder and wallet analysis: inspect_token, token_wallets, token_graph, token_web, compare_tokens, and find_serial_insiders reveal who holds a token, insider/sniper/fresh-wallet clusters, shared wallets, and serial insider patterns.
Wallet forensics: check_wallet, wallet_network, kol_leaderboard, and kol_record trace a wallet's history, its network, and tracked KOL trading records.
Exit and price checks: can_i_exit runs live Jupiter buy/sell quotes, token_price_path shows post-analysis price action, and token_changes detects holders selling now.
Deep reports: token_identity, token_report, fetch, and get_sample produce comprehensive single-token documents, including creator history and sibling tokens.
Funder intelligence: funder_networks ranks funders seeding fresh wallets and identifies exchange-linked addresses.
ChatGPT compatibility: search and fetch expose the same data in {id, title, url} / document form for research agents.
Payment model: pay-per-call in USDC, with a local key, x402 support, and no charge for unknown tokens, failed calls, or empty results.
Provides Solana token risk analysis and memecoin rug-check tools, including token screening, wallet profiling, insider and sniper detection, holder clusters, KOL tracking, price path monitoring, and live sellability checks across indexed pump.fun and letsbonk launches.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Solana memecoin rug check and token risk for trading agents, as MCP tools: pump.fun launches and migrations, calibrated rug probability, sniper / insider / bundle and fresh-wallet detection, holder clusters, KOL trades, wallet history across every launch indexed, and a live sellability check before you buy. Built for the trenches.
Add to your MCP client config — Claude Desktop, Cursor, Codex, or anything else that speaks MCP:
{
"mcpServers": {
"mindjack": {
"command": "npx",
"args": ["-y", "@mindjack/mcp"]
}
}
}That is the whole setup. No signup, no card: the server mints a key on first
use, saves it to ~/.config/mindjack/key, and reuses it from then on. A new
key starts empty — fund it with a USDC deposit when you are ready; the free
tools below work before you fund anything, and get_sample answers one real
token in full so you can see every paid tier before spending a cent.
Set MINDJACK_API_KEY to use a specific key instead, or MINDJACK_CONFIG_DIR
to keep it somewhere else.
Prefer to skip keys entirely? The API also speaks x402 — pay per call in USDC on Solana, no account at all.
Related MCP server: NoesisAPI
Tool | Price | Answers |
| free | One fixed token, answered in full — no key, no payment |
| free | What we hold, how fresh, and a mint that works |
| free | Our measured hit rate per risk band |
| free | What is left on your key |
| $0.001 | Is this one dangerous, and how fast do these collapse |
| $0.005 | Which tokens are worth looking at, verdicts attached |
| $0.005 /page | Find any token we ever analysed, by symbol, name or mint |
| $0.005 /page | The same search, shaped for research clients: |
| $0.005 | Who is holding it, and what kind of wallets |
| $0.005 | The named wallets behind it: insiders, snipers, fresh, wash, KOLs — with funders and clusters |
| $0.005 | What it did after we called it |
| $0.005 | Can it be sold right now — a live Jupiter round trip at $100 and $1000 |
| $0.006 | Who is this wallet, across every token we indexed |
| $0.02 /page | Every tracked KOL ranked: realized SOL, win rate, recent window |
| $0.02 | One KOL's full record: per-token history and latest trades |
| $0.025 | Who is behind it, and how their earlier tokens ended |
| $0.025 | Everything on one token in one call; |
| $0.025 | The same report as one document, keyed by the |
| $0.025 | Who sold since we analysed it (reads the chain now) |
| $0.025 | What happened to tokens shaped like this |
| $0.025 / 25 | Who keeps turning up as an insider, across the whole index |
| $0.025 | Were these 2-4 tokens run by the same people |
| $0.025 | Who a wallet moves with: counterparts, direction, second hop |
| $0.025 /page | Funders seeding fresh wallets index-wide, exchanges named |
| $0.04 | How the holders are connected: edges, clusters, wash wallets |
| $0.04 | Launches tied to this one through shared wallets, with outcomes and peaks |
search and fetch are aliases, not extra products: same endpoints, same
prices, same billing as search_tokens and token_report. They exist under
those exact names because ChatGPT's deep research and company knowledge modes
look for them by name and connect to nothing without them.
Live feeds (new launches, watched wallets, KOL trades) are server-sent event streams and do not map to MCP tools — the endpoint guide below covers them.
Four read-only documents, all free, attached once rather than called per task. A client can cache them; the model does not have to decide to fetch them.
URI | What it is |
| The window we hold, what is in it, and a live mint guaranteed to have data |
| Every calibrated band with the collapse rate measured for it and its sample size |
| Every priced route with its price, asset, network and receiving address |
| One real token answered in full, free, so you can read the shape before buying it |
Three workflows, written down. Each is the order of calls that answers a real question, with what to read out of each step and when the next one is worth its price.
Prompt | Arguments | Answers |
|
| Should I take a position in this token? |
|
| What launched recently that is worth a closer look? |
|
| Who is this wallet and what has it done before? |
MCP passes prompt arguments as strings, so send "6" rather than 6.
Every tool declares an outputSchema and returns structuredContent beside
the text, so a client can validate the answer and plan the next call from the
field names without paying to discover the shape.
A first run, in the order the server itself recommends:
get_coverage -> free; the window, and a mint that works
find_tokens hours=24 max_rug_pct=45 -> candidates, each with a measured verdict
check_token mint=<from above> -> $0.001; structure and collapse speed
token_identity mint=<survivor> -> $0.025; who is holding it and how their
other tokens endedmax_rug_pct is worth one warning: it is a measured collapse frequency for
a calibrated band, not a score that starts at zero. The safest band we publish
still rugged about 35% of the time, so a threshold under that matches nothing
at any window length. The universe base rate is 45%.
We keep outcomes. Most APIs describe a token as it looks right now. We also
know what happened to every launch we have indexed since March 2026 — tens of
thousands of them — which is why check_token can tell you that tokens scoring
like this one collapsed 78% of the time rather than just handing you a number.
We publish our hit rate. get_scorecard returns the measured accuracy of
every band, refreshed weekly. Nobody who does not keep labelled outcomes can
produce that, and you should not trust a risk score from anyone who won't.
Collapse speed, not just collapse probability. In this market almost everything eventually dies, so "will it" separates weakly. "How fast" separates about tenfold — the worst band's median collapse is 19 seconds from peak, the cleanest is 11 minutes. That is the number that decides whether a position is exitable at all.
Wallets have a past. Millions of recorded wallet appearances. When the same wallets
show up in a new launch, token_identity tells you where else they have been
and how those ended.
Solana only, and only tokens indexed at migration. We hold every pump.fun and letsbonk migration since our start date — complete inside that window, nothing before it. The record is point-in-time and cannot be rebuilt later.
We do not predict price. Where upside is reported it is a measured historical frequency for a cohort, not a forecast, and not adjusted for fees or slippage.
Unknown tokens, failed calls and empty results cost nothing. Every
response carries _meta.coverage and _meta.billing so you can see exactly
what you got and what it cost.
Endpoint guide an LLM can read in one fetch: https://api.mindjack.xyz/llms.txt
Source, issues and releases: https://github.com/freyotrisolana/mindjack-mcp
Listings: npm, MCP Registry, Smithery, Glama, Cursor Directory, verifymcp
[$0.005] Can this token be sold RIGHT NOW, and what does a round trip cost: real Jupiter buy and sell routes at $100 and $1000, and the fraction of your money that survives. Verdict follows the worst rung: clear / elevated / thin / trapped / blocked. Quotes only, nothing is signed; not cached, takes a few hundred ms.
Inputs: mint (required). Returns: exit, mint, says, _meta, +2 more
[$0.001] Is this Solana token dangerous? A calibrated rug verdict whose probability is a MEASURED frequency (see get_scorecard), the concentration facts behind it, and how fast this band tends to collapse. Cheapest call, run it on every token; it decides whether inspect_token, token_identity or token_report is worth paying for. Does not name holders.
Inputs: mint (required). Returns: mint, name, _meta, facts, +3 more
[$0.006] One wallet across every token we indexed: launches it appeared in, how many ran, roles it recurs in, realised record. Works for any address. kol_record is the per-trade history of tracked KOLs; wallet_network is who this wallet moves with.
Inputs: address (required). Returns: says, _meta, known, wallet, +2 more
[$0.025] Were these tokens run by the same people? Give 2-4 mints and get the wallets appearing in more than one, each with the role it played in each. Weigh the roles rather than the count: shared holders are common, a wallet that was an insider in one and a sniper in the next is not. Mints outside our index come back named in not_covered.
Inputs: mints (required). Returns: says, _meta, count, in_all, +3 more
[$0.025] ChatGPT entry point: everything we hold on one token as one document: the calibrated verdict with its measured hit rate, who holds it and how they connect, and whether it can still be sold. Takes an id from search. Same endpoint and price as token_report, which other clients should call.
Inputs: id (required). Returns: id, url, text, title, +1 more
[$0.025 per 25] Wallets that keep turning up as insiders across the whole index. Each row carries the wallet's full footprint, because ranking on insider count alone puts bots on top (the highest is flagged in 1,642 tokens and holds 4,091). Read insider_in against also_held: close is a real serial insider, far apart is a bot.
Inputs: limit, min_tokens. Returns: says, _meta, count, filters, +1 more
[$0.005] Recently analysed tokens, each already carrying a verdict, to rank locally before paying for depth. Filters: hours (1-168), min_mcap, platform, limit (1-100). A time-ordered feed with no query; to find a token you know by name or mint, use search_tokens.
Inputs: hours, limit, min_mcap, platform. Returns: says, _meta, count, tokens, +1 more
[$0.025/page] Funders ranked by how many fresh wallets they seeded across the whole index, each labelled when we know the exchange behind it. A funder inside one token is a line item; across the index it is a desk. A null label with a high count is the shape worth opening.
Inputs: limit, min_wallets. Returns: says, _meta, count, filters, +1 more
[free] Credits remaining on your key. There is no free allowance: a new key starts at zero and is funded with a USDC deposit, so a balance of 0 means the paid tools will answer 402 until you top up.
Inputs: no named parameters. Returns: plan, key_prefix, credit_balance, free_remaining, +2 more
[free] What we hold and how fresh, plus a live example mint guaranteed to have data. Call this first: we index every pump.fun and letsbonk migration since our start date, so an older token you already know will return nothing.
Inputs: no named parameters. Returns: _meta, index, stats, pricing, +5 more
[free, no key] One fixed token answered in full: the complete check_token, inspect_token and token_identity responses, each carrying the price that call costs. Served by the same handlers as the paid tools, so it is what you would actually get. Use get_coverage for freshness, this for depth.
Inputs: no named parameters. Returns: mint, next, says, _meta, +4 more
[free] Our measured hit rate per risk band, and how fast each band tends to collapse. Read this to decide how much weight to give our verdicts. Most risk APIs ask you to trust a score; this one shows how it performed.
Inputs: no named parameters. Returns: says, _meta, bands, window_days, +2 more
[$0.005] Who is involved: top holders and supply, the sniper / fresh-wallet / insider / early-buyer split, connected-group topology, tracked-trader activity. Counts and structure only: token_wallets names them, token_graph draws the edges, token_web follows them to earlier launches.
Inputs: mint (required). Returns: mint, _meta, groups, activity, +5 more
[$0.02/page] Every tracked KOL wallet, ranked from the recorded trades: lifetime realized SOL, per-token win rate on NET realized SOL, and a recent-activity window. Sort by profit, success or activity. Use to build or refresh a copy-trading watchlist.
Inputs: days, sort, limit. Returns: kols, says, _meta, count, +1 more
[$0.02] One tracked KOL in depth: lifetime stats, per-token history from every recorded trade (buys, sells, volume, realized SOL) and the latest trades raw. Untracked addresses answer null and cost nothing; check_wallet covers any wallet.
Inputs: address (required). Returns: kol, _meta, tokens, recent_trades
[$0.005/page] ChatGPT entry point: the same catalogue search as search_tokens (same endpoint and price) returning {id, title, url} rows, each id a Solana mint for fetch. ChatGPT connects to nothing without this exact name; other clients should call search_tokens.
Inputs: query (required), limit. Returns: says, _meta, count, results
[$0.005/page] Find a token in the analysed catalogue by symbol, name fragment or exact mint, with platform, size and age filters. find_tokens lists what just migrated; this finds the one you mean. search is the same call in the shape ChatGPT requires.
Inputs: q, days, limit, offset, +2 more. Returns: says, _meta, count, query, +1 more
[$0.025] Measure what happened to every indexed launch matching your filters: rug rate against the index base rate, peak-gain percentiles, time to peak, collapse speed. Answers pattern questions like 'do launches with under 200 holders die faster?'; to shortlist live tokens to act on, use find_tokens instead. filters is {field: {min,max}} over numeric fields listed by get_coverage, e.g. {total_holders: {min: 200}}. Returns cohort aggregates and a one-sentence finding, never per-token rows. Read-only over stored history; measured past, not a forecast.
Inputs: filters (required), window_days. Returns: says, _meta, cohort, filters, +2 more
[$0.025] Who sold since we analysed it: reads the chain now and diffs the large positions against what we recorded. Use when a cached read feels stale or to see whether concentrated wallets are exiting. The only call that touches the chain live.
Inputs: mint (required). Returns: mint, says, _meta, ready, +1 more
[$0.04] The wallet relationship graph behind a token: edges with strength and confidence, cluster membership and role, wash-trading wallets. token_wallets names the holders; this shows how they are CONNECTED and whether a distributed-looking set is one person. Not a first look.
Inputs: mint (required). Returns: mint, says, _meta, edges, +4 more
[$0.025] Who is BEHIND this token: what its largest holders did in earlier launches, which sibling tokens the same wallets ran and how those ended, and the measured upside band. The decision-point call. Coverage is reported per call; an empty result is free.
Inputs: mint (required). Returns: mint, _meta, upside, creator, +3 more
[$0.005] What the token did after we called it: peak, drawdown from peak, and where it stands now, at 4-5 second resolution. Our feed starts at analysis; the bonding-curve phase before that is not included.
Inputs: mint (required). Returns: mint, path, says, _meta, +1 more
[$0.025] check_token + inspect_token + token_identity in one call. depth="full" ($0.07) adds the outcome path, live sellability and the wallet graph. Cheaper than the parts; use once a token is worth a real look. fetch is this call under the name ChatGPT requires.
Inputs: mint (required), depth. Returns: mint, says, _meta, depth, +3 more
[$0.005] The NAMED wallets behind one token: insiders, snipers, early buyers, fresh wallets, wash traders and tracked KOLs, each with funder (exchanges named), link count and cluster. Lists cap at 100 per class; *_total fields carry real counts. inspect_token gives counts, this gives addresses.
Inputs: mint (required). Returns: kols, mint, says, _meta, +12 more
[$0.04] Earlier launches tied to this token through shared wallets, with the wallets themselves, each launch's outcome and its highest recorded market cap. Use when token_identity reported shared wallets and you need WHICH launches. token_graph stays inside one token; this crosses tokens.
Inputs: mint (required), min_shared. Returns: mint, says, _meta, tokens, +2 more
[$0.025] Who one wallet is wired to across the index: direct counterparts with interaction counts, shared tokens, transfer direction where the chain shows it, plus a bounded second hop. check_wallet says what it DID; this says who it MOVES WITH.
Inputs: address (required). Returns: says, _meta, direct, wallet, +3 more
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 26 tools
Most tools have clearly differentiated roles, and descriptions cross-reference each other explicitly (verdict vs. holder counts vs. named wallets vs. graph; wallet history vs. network vs. KOL record). The main ambiguity comes from exact duplicate aliases like search/search_tokens and fetch/token_report, plus close neighbors like token_identity and token_web, though these are documented.
All names use snake_case and recognizable prefixes like token_, wallet_, kol_, find_, search_, and get_, so the set is readable and predictable. The pattern is weakened by object-first names like token_report and token_wallets sitting alongside verb-first names like check_token and find_tokens, and by the standalone aliases search and fetch.
26 tools is above the 25-tool threshold and the count is inflated by duplicate ChatGPT aliases plus many fine-grained variants covering closely related territory (inspect_token/token_wallets/token_graph, check_wallet/wallet_network/kol_record). A consolidated set of 15-18 tools would serve the same purpose with less surface area.
The tool surface covers the core token-intelligence workflow well: danger screening, holder and wallet forensics, exit viability, identity tracing, token discovery, KOL/funder tracking, and cohort analytics. Minor gaps exist—no dedicated live price/metadata call, no pre-analysis price history, and no general token-level transaction feed—but agents can work around them.
Solana + pump.fun intel for agents: launch verdicts, token risk, dev/wallet records, smart money.
Solana + pump.fun intel for agents: launch verdicts, token risk, dev/wallet records, smart money.
Memecoin safety scanner for Solana, BNB and Robinhood Chain with an onchain track record
Solana token rug-risk scores. Free basic score; full report pay-per-call via x402 (0.03 USDC).