Rugsight
OfficialThis server allows you to check the rug-pull risk of Solana SPL tokens by performing automated technical on-chain analysis.
Retrieve a free, quick risk score (0-100), grade (A-F), verdict, and flag codes for any Solana token.
Generate a detailed full risk report (0.03 USDC via x402) explaining every risk flag, holder breakdown, liquidity, and 24h volume.
Analyze token attributes including authority status, Token-2022 extensions, holder concentration, liquidity levels, and token age.
Provides tools for scoring Solana SPL token rug-pull risk from public on-chain data, including a free risk score and a paid full risk report via x402 USDC payments on Solana mainnet.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Rugsight
See the rug before it's pulled. Rugsight scores the rug-pull risk of any Solana SPL token from public on-chain data, and explains every flag. It is built for humans and for AI agents.
Free API:
GET https://rugsight.rugsight.workers.dev/api/score/{mint}(score, grade, verdict, flag codes)Paid API for agents (x402):
GET https://rugsight.rugsight.workers.dev/api/v1/report?mint={mint}, 0.03 USDC per call on Solana mainnet. No API key, no signup.Remote MCP server:
https://rugsight.rugsight.workers.dev/mcp(streamable HTTP). Tools:get_token_risk_score(free) andget_token_risk_report(x402, 0.03 USDC).Telegram bot: @rugsight_bot. Send
/check {mint}for the free score,/newfor freshly launched tokens. Works in groups (guide).Humans: the full report on the website costs 1 USDC (or the same value in SOL), paid with Solana Pay. Payments are crypto-only.
Discovery:
/.well-known/x402,/openapi.json,/llms.txt,/.well-known/mcp/server-card.json
# free score for BONK
curl https://rugsight.rugsight.workers.dev/api/score/DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263Client libraries (zero dependencies, typed):
npm i rugsight # Node 18+, Bun, Deno, browsers, Workers
pip install rugsight # Python 3.9+, standard library onlyVercel AI SDK tools: npm i rugsight-ai-sdk (guide).
import { Rugsight } from "rugsight";
const s = await new Rugsight().getScore("DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263");
console.log(s.score, s.grade, s.verdict);from rugsight import Rugsight
s = Rugsight().get_score("DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263")
print(s["score"], s["grade"], s["verdict"])MCP client config (any client that supports remote streamable-HTTP servers):
{ "mcpServers": { "rugsight": { "url": "https://rugsight.rugsight.workers.dev/mcp" } } }Integrations: copy-paste examples for LangChain/LangGraph (JS and Python), Vercel AI SDK, Solana Agent Kit, ElizaOS, x402 clients and MCP clients (Claude, Cursor, Windsurf, VS Code) are in integrations/. The client libraries are rugsight on npm (source: packages/js) and rugsight on PyPI (source: packages/python).
Not financial advice. Rugsight publishes automated technical analysis of public blockchain data. A good score does not mean a token is safe, and a bad score does not mean it is a scam. Do your own research.
Telegram bot
@rugsight_bot gives the free score inside Telegram, in private chats and groups.
/check DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263 # score, grade, verdict and flags
/new # recently launched tokens, already checked
/helpIn a private chat you can also just paste a mint address. In groups the bot only answers commands and mentions, and requests are rate-limited per chat. Each answer links to the token page and the 1 USDC full report. Deep links work too: https://t.me/rugsight_bot?start={mint}. The bot runs in the same Worker through a webhook (src/telegram.ts, POST /telegram/webhook, verified with Telegram's secret-token header); see scripts/telegram-setup.sh to run your own.
Related MCP server: soldefi-mcp
Stack ($0 to run)
Piece | Service | Cost |
API + static site | Cloudflare Workers + static assets | free tier |
Orders | Cloudflare D1 (SQLite) | free tier |
Cache (scores 5 min, reports 7 days, SOL price 2 min) | Cloudflare KV | free tier |
Chain data | Solana JSON-RPC: Helius free key, or any RPC | free tier |
Market data | DexScreener public API (all pools), falling back to Jupiter token API, then a last-good KV copy (<30 min); used for our own metrics only | free |
Payments | Solana Pay transfer requests, checked on-chain | network fee is paid by the buyer |
Agent payments | x402 v2 (v1 compatible) through the PayAI facilitator (1,000 free credits, no key) | free |
What it checks
Each score starts at 100. Every risk flag subtracts points. Grades: A ≥ 85, B ≥ 70, C ≥ 50, D ≥ 30, F otherwise.
Area | Flags (points) |
Authorities |
|
Token-2022 extensions |
|
Holders: wallets only, excluding pools, programs and burn addresses |
|
Liquidity |
|
Age |
|
If holder data cannot be read (for example, tokens with millions of holders such as USDC, which RPCs refuse to rank), the result is marked confidence: "partial" and the grade is capped at B.
Data policy: we publish only metrics we compute ourselves: scores, flags, buckets and percentages. We do not pass on raw third-party data. For example, liquidity and volume appear as ranges, not as DexScreener's figures.
API
Method | Path | Description |
GET |
| Free basic score: score, grade, verdict, flag codes and confidence |
POST |
| Creates a 1-USD order. Returns a Solana Pay URL, a QR code, and status and report URLs |
GET |
| Order status. Checks the chain for a payment that carries the order's reference key |
GET |
| Solana Pay QR code |
GET |
| Full report. Returns |
GET |
| x402 pay-per-call full report (0.03 USDC). Also |
POST |
| Remote MCP server (streamable HTTP): |
GET |
| Discovery documents |
GET |
| Free JSON feed: the last ~100 recently launched tokens (>= $5k liquidity) checked by the cron trigger, plus aggregate stats. Also |
GET |
| Side-by-side comparison pages for ~50 curated same-category pairs (e.g. |
POST |
| Runs the feed now. Needs |
GET |
| Shows whether payments, x402 (and whether the treasury USDC account exists) and the RPC are configured |
Example:
curl https://<your-worker>/api/score/DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263x402 pay-per-call (agents)
An unpaid
GET /api/v1/report?mint=…returns402. ThePAYMENT-REQUIREDheader carries the base64 x402 v2PaymentRequired(schemeexact, networksolana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp, 30000 base units of USDC to the treasury, fee payer = PayAI sponsor, Bazaar discovery extension). The body carries the x402 v1 form for older clients.The client retries with
PAYMENT-SIGNATURE(v2) orX-PAYMENT(v1).The worker decodes the partially signed transaction and rejects it locally if the fee payer, the destination ATA, the mint or the amount is wrong. Then it calls the facilitator's
/verify.It builds the report. If that fails, it answers
503and does not settle, so the payer is not charged.It calls
/settle, returns the report withPAYMENT-RESPONSE, and logs the settlement inx402_payments.
The treasury must own a USDC token account (TREASURY_USDC_ATA) before x402 transfers can land; /api/health reports x402PayToReady.
How a Solana Pay payment is verified
POST /api/orderscreates a randomreferencepublic key and stores the order in D1.The buyer's wallet opens
solana:<TREASURY>?amount=..&spl-token=<USDC>&reference=<ref>. Thespl-tokenparameter is left out for SOL payments.GET /api/orders/:idcallsgetSignaturesForAddress(reference)andgetTransaction. It accepts the order only if the transaction succeeded and the treasury's USDC token balance (or SOL balance) rose by at least the quoted amount.orders.signatureisUNIQUE, so one transaction can pay for only one order.
A SOL quote uses the SOL/USD price from DexScreener at order time and is rounded up.
Local development (no Cloudflare account needed)
npm install
npm run db:local # apply migrations/0001_init.sql to the local D1
npm run relay # see note below (port 8899)
npm run dev:local # http://localhost:8799
npm run typecheck
npm test # checks the payment verifier against real mainnet transactions (read-only)
npm run analyze -- <mint> # runs the scoring engine directly in NodeRPC note: the public endpoint api.mainnet-beta.solana.com blocks requests sent from Cloudflare Workers.
Those requests carry a CF-Worker header, and the endpoint answers 403.
It also rate-limits getTokenLargestAccounts (HTTP 429).
For local tests, test/rpc-relay.mjs forwards requests without that header.
In production, set HELIUS_API_KEY. A free Helius key is enough. You can also point SOLANA_RPC_URL at another provider.
Without a key, holder data is available only for Token-2022 tokens, such as new pump.fun launches. This comes from an account-scan fallback.
Run locally (stdio)
stdio/ is a small MCP server that talks over stdio. It's a thin client for the hosted API, so all analysis runs on the hosted service, and it holds no keys or wallets.
It exposes the same tools as the hosted /mcp endpoint:
get_token_risk_score: free. CallsGET /api/score/<mint>.get_token_risk_report: 0.03 USDC per call via x402, settled by the hosted service. Without a payment, the tool returns thePaymentRequiredobject. To pay, retry thetools/callwith_meta["x402/payment"](an x402 v2 PaymentPayload), and the local server forwards it to the hosted/mcp.
cd stdio && npm ci
node index.js # speaks MCP over stdin/stdout
npm test # smoke test: initialize, tools/list, score for BONK, 402 for the reportClaude Desktop, Cursor, or any stdio MCP client:
{ "mcpServers": { "rugsight": { "command": "node", "args": ["/path/to/rugsight/stdio/index.js"] } } }Environment variables:
RUGSIGHT_API_URL: base URL of the API. Defaults tohttps://rugsight.rugsight.workers.dev, and you can point it at your own deployment.RUGSIGHT_TIMEOUT_MS: request timeout. Defaults to 30000.
Docker: docker build -t rugsight-mcp . && docker run -i --rm rugsight-mcp. The image needs Node 18 or later. The Dockerfile uses Node 20.
Configuration (wrangler.toml → [vars]; secrets via wrangler secret put)
Var | Default | Notes |
|
| Receives every payment |
|
| Full report price |
|
| Quote validity. Payments that arrive late are still honoured |
| public mainnet | Ignored when |
| none | Needed in production |
|
| Set this to the deployed URL |
| none | Protects |
|
| x402 settings; tests: |
Self-host (deploy your own)
Rugsight runs entirely on the Cloudflare Workers free tier. Change TREASURY_ADDRESS, TREASURY_USDC_ATA and PUBLIC_BASE_URL in wrangler.toml to your own wallet and URL first, otherwise payments go to the Rugsight treasury.
npx wrangler login # Cloudflare account (free)
npx wrangler kv namespace create CACHE # copy the id into wrangler.toml
npx wrangler d1 create rugsight # copy database_id into wrangler.toml
npx wrangler d1 migrations apply rugsight --remote
npx wrangler secret put HELIUS_API_KEY
# set PUBLIC_BASE_URL in wrangler.toml to https://rugsight.<subdomain>.workers.dev
npx wrangler deploy
curl https://rugsight.<subdomain>.workers.dev/api/healthSchema
See migrations/0001_init.sql (also copied as schema.sql).
It has two tables: orders (Solana Pay orders) and x402_payments (a settlement log for pay-per-call).
License
MIT. Contact: yunare-qwerng+rugsight@mail.grokbot.com · X: @rugsightapp
New-token feed
A cron trigger (*/30 * * * *) pulls recently launched or trending Solana tokens from Jupiter's public lists
(toptraded, toptrending, recent) and DexScreener's latest profiles and boosts. It keeps tokens with at least $5k liquidity whose first pool is under 72 hours old, then
analyzes up to 15 new ones per run. Each analysis runs in its own invocation through a self service binding
(FEED → FeedWorker), so the free plan's per-invocation CPU and subrequest limits apply to each analysis separately. Results go to D1
(new_tokens). One KV snapshot per run serves /new, /new.xml and /api/new. Token pages for feed mints are
noindex unless liquidity is at least $50k. Worst-case budget: 720 analyses per day, about 4.5k Helius credits per day, at most 720 D1 writes
and 48 KV writes per day. See src/feed.ts.
Available Tools
2 toolsget_token_risk_reportSolana token full risk report (0.03 USDC, x402)ARead-onlyInspect
Full Rugsight risk report: every flag explained, top-20 holder breakdown, liquidity, 24h volume, pool age. Costs 0.03 USDC on Solana per call, paid with x402 on the hosted service: call without payment to receive the PaymentRequired object, then retry with _meta["x402/payment"] (x402 v2 PaymentPayload). Not financial advice.
Inputs: mint (required).
get_token_risk_scoreSolana token risk score (free)ARead-onlyInspect
Quick rug-risk check for a Solana SPL / Token-2022 token: 0-100 score, A-F grade, verdict and risk flag codes (mint & freeze authority, Token-2022 extensions, holder concentration, liquidity). Free, no payment needed. Calls the hosted Rugsight API. Automated technical data, not financial advice.
Inputs: mint (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 2 tools
Both tools assess token rug risk, so the underlying purpose overlaps, but the descriptions make the boundary clear: one is a free 0-100 score/grade snapshot, the other is a paid full report with holder and liquidity detail. An agent can reliably pick based on depth and payment willingness, though the near-identical names invite a quick double-check.
Both names follow the same get_token_risk_* snake_case verb_noun pattern with a shared prefix, making the pair read as a deliberate, predictable family. No mixing of conventions.
Two tools is on the thin side even for a narrow risk-scoring service; the surface is essentially one capability offered at two depths. It is defensible for a focused hosted API, but leaves little room for adjacent operations.
The core domain — token risk assessment — is covered at both summary and detailed levels, including flags, holders, liquidity, and pool age, so there are no dead ends for the primary workflow. Minor gaps exist: no batch/multi-token check, no historical or cached report retrieval, and no way to list or search tokens.
Related MCP Connectors
Solana token/wallet rug-risk scoring. Free scan; $2 SOL unlocks full wallet report. No signup.
Solana token rug check before you buy: SAFE/CAUTION/DANGER from chain state, paid per call via x402.
Solana token rug/honeypot checks: free quick check; full score paid via x402 (USDC Solana/Base).
Rug-risk checks for Solana + Base tokens (free trial), token data, tx explainer. x402 pay-per-call.
Related MCP Servers
- AlicenseAqualityCmaintenanceOn-chain Solana token safety for trading agents — traces coordinated wallet funding, same-block Jito bundles, serial-rug deployers and live coordinated dumps into one Exit-Liquidity Risk verdict before a swap. Free tier, then $0.02 USDC/query via x402.12MIT
- AlicenseAqualityDmaintenancePaid access to Solana DeFi risk intelligence — rug/honeypot scans, liquidity-pool analysis, and wash-trade-filtered pool rankings. Automatically settles micropayments in USDC via x402.10160 npmMIT
- AlicenseAqualityCmaintenanceOn-chain Solana cabal & rug detection as an MCP server. Scans any Solana token mint before your agent buys and returns an Exit-Liquidity Risk verdict.131 npm2MIT
- AlicenseAqualityCmaintenanceSolana memecoin rug check and token risk for trading agents in the trenches: pump.fun launches, calibrated rug probability with a published hit rate, sniper, insider and bundle detection, holder clusters, KOL trades, wallet history and a live sellability check for memecoins. Available as a remote MCP endpoint (OAuth or API key) and as an npm stdio package.26246 npm3MIT