token-safety-check
Rug-check a token and get a risk score, plain-language reasons, underlying facts, and market data, with optional change tracking since a prior fingerprint.
Check tokens on
base,eth,arbitrum,optimism,polygon, orsolana.Provide a required token
address; ifchainis omitted, it defaults tosolanafor base58 addresses andbaseotherwise.Get a 0–100 risk score with reasons such as mint/freeze/blacklist/fee/pause powers, upgradeable code, holder concentration, and thin liquidity.
View supporting facts plus USD price and liquidity.
Pass a previous
watch.fingerprintassinceto see what changed.Each check costs $0.01 in USDC on Base.
Provides a Coinbase AgentKit action provider (customActionProvider) that lets AgentKit agents rug-check any token by passing a contract or mint address and chain, returning a 0-100 risk score with reasons as JSON.
Supports rug-checking tokens on Ethereum (chain eth), reporting mint/freeze/blacklist/pause powers, upgradeable code, holder concentration, liquidity, price and authority changes between checks.
Exposes the token safety check as a LangChain JS tool that agents can call with a token address and optional chain to get a JSON rug-check report with risk score, reasons, market data and a change fingerprint.
Supports rug-checking tokens on the Optimism chain, returning risk scores with plain-language reasons, market data and a fingerprint to track changes over time.
Supports rug-checking tokens on the Polygon chain, returning risk scores with plain-language reasons, market data and a fingerprint to track changes over time.
Supports rug-checking Solana tokens by mint address, including Token-2022 permanent delegates, transfer fees and hooks, plus holder concentration, liquidity and authority change tracking.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@token-safety-checkrug check this token on Base: 0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
token-safety-check
Is this token safe? A rug check for any token on Base, Ethereum, Arbitrum, Optimism, Polygon or Solana, for AI agents and scripts. Each check returns:
a 0–100 risk score and level (low, medium, high, critical) with plain-language reasons:
who can mint, freeze, blacklist, pause or change fees
upgradeable contract code
Token-2022 permanent delegates, transfer fees and hooks
holder concentration
thin or missing liquidity
a deployer whose earlier tokens lost their liquidity, or who launches tokens in bulk
the facts behind the score: owner, authorities, supply, top holders, pools, and the deployer's launch record when we saw the token launch;
USD price and liquidity;
a fingerprint. Pass it back as
sinceand the next check tells you what changed: new risks, authority changes, liquidity or price moves. That makes it easy to monitor tokens on a schedule.
A verdict call turns the same facts into a grade (CLEAN, MID, SKETCHY or RUGGY), a one-liner, a short take and a link to a share card, for chat replies and quests.
A watchlist call re-checks up to 5 tokens at once for the same $0.01, returning a compact entry per token and one-line alerts for whatever changed since your last call.
Checks, verdicts and watchlist calls cost $0.01 each in USDC on Base, paid automatically with x402 from a wallet you control. There's no account or API key. Errors and invalid input are never charged, and a spending cap stops any call priced above your limit (default $0.05).
The score is rules-based and is not investment advice. Powers count for less on tokens with deep liquidity, where they're usually a large issuer's compliance controls (USDC can freeze and mint, for example).
Use it from Claude Desktop, Cursor or any MCP client
Create a new wallet just for this and send it a little USDC on Base: $1 covers 100 checks. Then
add to your MCP config (for Claude Desktop, that's claude_desktop_config.json):
{
"mcpServers": {
"token-safety-check": {
"command": "npx",
"args": ["-y", "token-safety-check"],
"env": { "X402_PRIVATE_KEY": "0x<private key of the dedicated wallet>" }
}
}
}The server has three tools:
check_token_safety(address, optionalchainandsince): the full check for one token.token_verdict(address, optionalchain): a grade, one-liner, short take and share-card link.watch_tokens(tokens: up to 5 of{ address, chain?, since? }): re-checks them all in one paid call and, given each token's earlier fingerprint, reports what changed with one-line alerts.
Optional environment variables:
TOKEN_SAFETY_MAX_USD: per-check spending cap, default0.05.TOKEN_SAFETY_ENDPOINT: point at another deployment.
Related MCP server: token-safety
Use it from code
npm install token-safety-checkimport { createTokenSafetyClient } from "token-safety-check";
const client = createTokenSafetyClient({ privateKey: process.env.X402_PRIVATE_KEY as `0x${string}` });
const first = await client.checkToken({ chain: "base", address: "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed" });
console.log(first.risk.score, first.risk.level, first.risk.summary);
// 15 low Low risk: the owner can pause all transfers; ownership is not renounced.
// Later: what changed since then?
const later = await client.checkToken({ address: first.address, chain: "base", since: first.watch.fingerprint });
if (later.watch.changes?.anythingChanged) console.log(later.watch.changes);A verdict for a chat reply
const v = await client.verdict({ address: "0xe468f13905669748bf312611b9ebcc8ccc6db5d9" });
console.log(v.grade, v.oneLiner); // SKETCHY Liquidity: two coins and a prayer
console.log(v.take, v.card); // "$KTI: 60/100 risk. ..." and a signed share-card link
// Pass requestKey (8-128 letters, digits or _.:-) and a retry with the same key is never charged twice.Watch what you hold
let list = [
{ chain: "base", address: "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed" },
{ chain: "solana", address: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN" },
] as const;
let fingerprints: (string | undefined)[] = [];
// Every hour (or however often): one $0.01 call for the whole list.
const w = await client.watchlist(list.map((t, i) => ({ ...t, since: fingerprints[i] })));
for (const alert of w.alerts) console.log(alert); // e.g. "PEPINA (eth): risk 0 -> 30 (medium); liquidity -99.99%"
fingerprints = w.tokens.map((t) => t.fingerprint);Use it in the Vercel AI SDK or Mastra
token-safety-check/ai gives three ready tools (checkTokenSafety, tokenVerdict, watchTokens),
plain { description, inputSchema, execute } objects that both take as tools:
import { generateText } from "ai";
import { createTokenSafetyClient } from "token-safety-check";
import { tokenSafetyTools } from "token-safety-check/ai";
const tools = tokenSafetyTools(createTokenSafetyClient({ privateKey: process.env.X402_PRIVATE_KEY as `0x${string}` }));
const { text } = await generateText({ model, tools, prompt: "Is 0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed on Base safe to buy?" });Use it in ElizaOS
token-safety-check/eliza is an ElizaOS 1.x plugin with one action, CHECK_TOKEN_SAFETY. When a
message names a token address ("is 0x… on Base safe?", "rug check "), the agent replies with
the verdict and a share-card link.
import { tokenSafetyPlugin } from "token-safety-check/eliza";
export const character = {
name: "trader",
plugins: [tokenSafetyPlugin],
settings: { secrets: { TOKEN_SAFETY_PRIVATE_KEY: process.env.TOKEN_SAFETY_PRIVATE_KEY } },
};Settings: TOKEN_SAFETY_PRIVATE_KEY (a dedicated wallet with a little USDC on Base; falls back to
X402_PRIVATE_KEY), optional TOKEN_SAFETY_MAX_USD (default 0.05) and TOKEN_SAFETY_ENDPOINT.
Use it in Coinbase AgentKit
import { customActionProvider } from "@coinbase/agentkit";
import { z } from "zod";
import { createTokenSafetyClient } from "token-safety-check";
const safety = createTokenSafetyClient({ privateKey: process.env.X402_PRIVATE_KEY as `0x${string}` });
export const tokenSafety = customActionProvider({
name: "check_token_safety",
description: "Rug check a token on Base, Ethereum, Arbitrum, Optimism, Polygon or Solana: 0-100 risk score with reasons.",
schema: z.object({
address: z.string().describe("Token contract or Solana mint address"),
chain: z.enum(["base", "eth", "arbitrum", "optimism", "polygon", "solana"]).optional(),
}),
invoke: async (args) => JSON.stringify(await safety.checkToken(args)),
});
// Add tokenSafety to the actionProviders you pass to AgentKit.from(...).Use it in LangChain (JS)
import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { createTokenSafetyClient } from "token-safety-check";
const safety = createTokenSafetyClient({ privateKey: process.env.X402_PRIVATE_KEY as `0x${string}` });
export const checkTokenSafety = tool(async (args) => JSON.stringify(await safety.checkToken(args)), {
name: "check_token_safety",
description: "Rug check a token on Base, Ethereum, Arbitrum, Optimism, Polygon or Solana: 0-100 risk score with reasons.",
schema: z.object({
address: z.string(),
chain: z.enum(["base", "eth", "arbitrum", "optimism", "polygon", "solana"]).optional(),
}),
});Example output (trimmed)
{
"address": "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed",
"chain": "base",
"name": "Degen",
"symbol": "DEGEN",
"risk": {
"score": 15,
"level": "low",
"reasons": [
{ "code": "can-pause", "points": 10, "text": "The owner can pause all transfers." },
{ "code": "owner-not-renounced", "points": 5, "text": "Ownership is not renounced." }
],
"summary": "Low risk: the owner can pause all transfers; ownership is not renounced."
},
"market": { "dex": "uniswap-v3", "pairedWith": "WETH", "priceUsd": 0.000963, "quoteSideLiquidityUsd": 134000 },
"watch": { "fingerprint": "eyJzIjoxNSwi…", "changes": null }
}Without this package
Both are plain x402 endpoints, so any x402 client can call them directly:
GET https://onchaincheck.dev/token?chain=<chain>&address=<address>[&since=<fingerprint>] and
GET https://onchaincheck.dev/watchlist?tokens=<chain>:<address>,...[&since=<fp>,...].
It's also listed in the x402 Bazaar.
Safety notes
Use a dedicated wallet with a small balance. The key never leaves your machine; it only signs USDC payments of the quoted price.
Each check's price is read from the server's payment request before paying, and anything above
maxUsdPerCheck/TOKEN_SAFETY_MAX_USDis refused.
MIT licensed.
Available Tools
1 toolcheck_token_safetyA
Rug check a token on Base, Ethereum, Arbitrum, Optimism, Polygon or Solana: a 0-100 risk score with plain reasons (mint, freeze, blacklist, fee or pause powers, upgradeable code, holder concentration, thin liquidity), the facts behind it, and USD price and liquidity. Pass a previous watch.fingerprint as since to see what changed. Costs $0.01 in USDC on Base per check.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Defaults to solana for base58 addresses, otherwise base | |
| since | No | watch.fingerprint from an earlier check | |
| address | Yes | Token contract (0x...) or Solana mint address |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses the per-call cost ($0.01 USDC on Base), the supported chains, and that it returns both a risk score and price/liquidity data. It does not cover failure modes (unsupported token, payment failure) or rate limits, which is a minor gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense paragraph that front-loads the core action and chains, then moves to output, then to the `since` workflow, then cost. Every clause carries information, though the parenthetical reason list is slightly long for the value it adds.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, yet the description fully characterizes the return value (score, plain-language reasons, underlying facts, USD price and liquidity). Combined with cost and chain coverage, an agent has everything needed to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, but the description adds real meaning by explaining that `since` is a watch.fingerprint from an earlier check used to surface changes, clarifying the diff semantics beyond the bare schema text. `address` and `chain` semantics are already fully described in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Rug check') plus resource (a token) and enumerates the six supported chains and the delivered artifact (0-100 risk score with reasons). An agent knows exactly what the tool does without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear contextual usage: it is the tool for rug-checking a token, and it explains the incremental workflow of passing a previous watch.fingerprint as `since` to see what changed. No siblings exist, so there are no alternatives to exclude, but there is also no guidance on when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
v0.1.0- First observed
check_token_safety
TDQS
Scored across 1 tool
There is only one tool, so there is no risk of selecting the wrong operation. Its purpose is clearly scoped to token rug/safety checks.
The single tool uses a clear snake_case verb_noun pattern: check_token_safety. With only one tool there is no inconsistency, and the name directly describes the action and target.
The server is intentionally single-purpose, so one tool is defensible, but a one-tool surface is thin and offers no separate discovery, batch, or historical comparison operations. It sits at the borderline for an MCP tool set.
The tool covers the core domain well: risk score, explanatory reasons, underlying facts, price, liquidity, multi-chain support, and change tracking via a previous fingerprint. No obvious lifecycle gaps exist for a token safety check.
Maintenance
Related MCP Connectors
Solana token rug-risk scores. Free basic score; full report pay-per-call via x402 (0.03 USDC).
Instant rug-check for any EVM or Solana token, distilled to one clear 0-10 risk verdict.
Base token risk screen: rug-pull liquidity, honeypots, copycats. Pay per call via x402 (USDC).
Rug check & honeypot flags for Base/Solana tokens. Free preview; full $0.0009/token via x402.
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.153 npm2MIT
- AlicenseNot gradedqualityCmaintenanceChecks token contract safety for honeypot, tax, proxy, blacklist, ownership risks, and returns a risk score, enabling rug-pull protection for agents via pay-per-call x402 micropayments.MIT
- AlicenseAqualityCmaintenanceEnables AI agents to check an EVM address on Base for risk (safe, caution, danger) before sending funds, with reasons, paid per call via x402 from the user's own wallet.7309 npm1MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to run honeypot and owner-power safety checks on Base tokens and to read wallet ETH and USDC balances, with every answer sourced from real chain data and paid per call in USDC via x402.MIT