A token can pass a rug-checker and still refuse to sell. The reason is a gap in how most checkers
work — they read the contract but never run it. Here's what a static scan can't
see, and what a simulation catches.
See it yourself
Paste a Base token — true402 runs the buy/sell simulation a static scan can't. Free, no wallet.
Powered by the free trial · for unlimited checks run npx @true402.dev/rugcheck 0x… or wire the API into an agent.
§01 · what a scan does
Read the contract for bad patterns.
A static rug scanner (Token Sniffer and most "rug checkers" work this way) reads the contract's bytecode or source and flags known-bad patterns: a mint function, a blacklist, a 100% sell tax, non-renounced ownership, lopsided holder distribution. It's fast, free, and genuinely useful for catching the obvious stuff.
§02 · the blind spot
It never runs the trade.
Because a static scan only reads, it can't see traps that only appear at runtime: an upgradeable proxy whose logic is swapped after launch, a sell that reverts only above a certain size (max-tx / anti-whale), a block that depends on external state, or conditions a static read just can't evaluate. The contract looks clean — and still won't let you sell.
§03 · what a simulation does
Actually buy, then sell.
A honeypot simulation trades the token without spending anything: it runs a buy then a sell in one gas-free eth_call with a state override — no real tx, no footprint — and checks whether the tokens come back out. Because it executes the real transfer path, it catches the runtime sell-block a scan can't. true402 probes at two sizes, so it also catches the small-sell-passes / large-sell-reverts trap.
§04 · the honest take
Use both — scan fast, simulate before you buy.
Static scans aren't useless — they're a fast, free first filter for the obvious red flags. But for anything you're about to actually buy, add a simulation that proves the sell works. The strongest check does both in one pass: true402's token-report runs structural checks (mint, ownership, proxy), liquidity depth, and the buy/sell simulation, then returns a single avoid/caution/ok verdict.
try it free — simulates the sell
# Free to try — a few checks a day, no wallet, no signup. Simulates the buy + sell on-chain.
npx @true402.dev/rugcheck 0x<token>
# ⚠️ CAUTION (score 75/100)
# • ownership is not renounced
# checked on-chain: honeypot sim + liquidity + ownership
Can a token pass a rug-checker and still be a honeypot?
Yes. Most rug-checkers do static analysis — they read the contract bytecode/source for known-bad patterns (a mint function, a blacklist, a 100% tax, non-renounced ownership). That catches the obvious traps, but it cannot run the contract, so it misses honeypots whose sell-blocking only happens at runtime: an upgradeable proxy whose logic is swapped after launch, a sell that reverts only above a size, a block that depends on external state, or conditions a static read can't evaluate. A token can look clean to a scanner and still refuse to sell. The only way to be sure is to simulate the sell.
Is a static rug scanner like Token Sniffer enough?
It's a useful first pass — fast, free, and good at flagging obvious red flags (mint, blacklist, fees, holder concentration). But static scanners share one blind spot: they don't execute the trade, so a honeypot that only blocks sells at runtime can pass. For anything you're about to actually buy, pair the static scan with a buy/sell simulation that proves the token can be sold. Best practice is both — structural checks for the obvious, a simulation for the trap a scan can't see.
What is a honeypot simulation and how does it work?
It actually trades the token, without spending anything. The check runs a buy and then a sell of the token in a single gas-free eth_call with a state override — no real transaction, no on-chain footprint — and measures whether the tokens come back out. If the sell reverts or returns dust, it's a honeypot. Because it executes the real transfer path, it catches runtime sell-blocks that static analysis can't see. true402 also probes at two sizes to catch max-transaction / anti-whale traps (sellable small, blocked at size).
How do I verify a token is sellable before I buy?
Run a check that simulates the round trip. true402's token-report (or the token-safety endpoint) buys-then-sells the token on-chain, checks liquidity depth and contract structure, and returns an avoid/caution/ok verdict — the simulation proves sellability, the structure check catches mint/ownership/proxy risk. It's free to try (a few checks a day, no wallet) via `npx @true402.dev/rugcheck 0x…`, then pay-per-call over x402 — no account, no API key.