Share on XShare on LinkedInShare on Telegram
Security Decisions/ Before launchWeb3 Security

What Is a Honeypot Token? How Scam Contracts Let You Buy but Not Sell

A honeypot token checker simulates a buy-then-sell cycle to see if a contract lets you exit. Learn the code patterns behind honeypot scams, from hidden blacklists to adjustable sell taxes and owner-only trading switches. See why a ‘safe’ result can still miss delayed triggers, plus a quick pre-buy checklist to verify a contract yourself.

Author
QuillAudits Team
•October 28, 2026
What Is a Honeypot Token? How Scam Contracts Let You Buy but Not Sell
Share on XShare on LinkedInShare on Telegram

The decision · answer in brief

A honeypot token checker simulates a buy-then-sell cycle to see if a contract lets you exit. Learn the code patterns behind honeypot scams, from hidden blacklists to adjustable sell taxes and owner-only trading switches. See why a ‘safe’ result can still miss delayed triggers, plus a quick pre-buy checklist to verify a contract yourself.

Honeypot Token Checker: How Scam Contracts Let You Buy, Not Sell

A honeypot token checker simulates a buy-then-sell cycle on a contract to see whether the sell actually goes through, and it's a useful first filter before you buy. This post walks through the exact contract code patterns a checker is trying to catch, how the simulation itself works, and why a "safe" result from one of these tools still isn't a verdict you should buy on without reading the code yourself.

What Is a Honeypot Token? (The Trade You Can Make and the One You Can't)

A honeypot token is a smart contract engineered so that buying works normally but selling doesn't. You send ETH or BNB, the swap goes through, your wallet shows a shiny new token balance, and the price chart looks like it's climbing. Try to sell, and the transaction reverts, gets taxed down to almost nothing, or just quietly fails. As Cointelegraph's reporting on Solidus Labs' 2022 Rug Pull Report describes it, a honeypot crypto scam is a smart contract that lets users buy or deposit a token freely but blocks or heavily penalizes selling, usually through a blacklist, hidden tax, or disabled transfer function.

The mechanism isn't a bug. It's the point. The deployer writes logic that treats your sell transaction differently from everyone else's buy transaction, then watches liquidity pour in while nobody can get it back out.

A honeypot is a different scam category from a rug pull, even though both show up in the same reports. A rug pull happens after the fact, usually when a developer drains or removes liquidity once enough buyers have piled in. A honeypot is built into the contract from the start: the selling restriction is code, not a later action, so the trap is armed before anyone buys.

The most notorious example remains Squid Game (SQUID), a token that rode its Netflix-adjacent name to a 45,000% gain in days before buyers discovered they couldn't sell at all, netting the scammers roughly $3.3 million. The pattern it popularized hasn't gone anywhere. QuillAudits' own breakdown of honeypot scams documents the full lifecycle, from development and deployment through engagement, exploitation, concealment, and collapse, and is worth reading for the fraud-awareness side of this.

This post stays on the code side: what the contract actually contains, what a checker tool simulates when it says "safe," and where that simulation still misses real traps.

The Code Patterns Behind Every Honeypot Contract

Every honeypot relies on the same basic trick: the transfer function behaves differently depending on who's selling, when they're selling, or how much tax gets deducted on the way out. Gate Learn's explainer on honeypot scams points to blacklist mappings as one of the most common mechanisms deployers use to block an address from selling. Here are four patterns that show up most often in deployed honeypot code.

Hidden Blacklist or Denylist Mappings

Most ERC-20 and BEP-20 tokens are a thin wrapper around OpenZeppelin's standard transfer logic. A honeypot adds a mapping(address => bool) tagged something like _isBlacklisted or _blocked, then inserts a require(!_isBlacklisted[sender]) check inside _transfer. The deployer's wallet is never on the list; every other buyer gets added to it, either right after purchase or the first time they try to sell. An unexplained mapping tied to a require inside the transfer function is one of the fastest manual checks you can do.

Extreme or Adjustable Sell Tax

Plenty of legitimate tokens charge a small buy or sell tax to fund liquidity or marketing. Honeypots abuse the same mechanism by making the sell tax a variable the owner can change after launch, often starting at a reasonable 2-5% and jumping to 90-99% once volume picks up. Look for a setSellTax or updateFees function with no upper bound enforced in code, or a tax rate read from a mutable state variable rather than a constant.

Disabled or Conditional Transfer Functions

Some honeypots skip taxes and blacklists entirely and gate the transfer function itself. A require(tradingEnabled, "Trading not active") check that the owner controls, or a condition like require(to == pancakeSwapRouter || from == owner), lets purchases route through the liquidity pool while blocking any transfer that isn't a buy. The function technically "works," it just never permits the direction you need.

Owner-Only Trading Switches and Hidden Modifiers

The broadest version of the pattern is a single boolean the owner flips, paired with a custom modifier applied inconsistently across the contract's functions. A swapEnabled or maxTxAmount variable only the deployer can adjust, combined with an onlyOwner modifier guarding the function that would otherwise let holders exit, gives the deployer a kill switch over the token's liquidity without touching the blacklist or tax logic at all.

How a Honeypot Token Checker Actually Works

A honeypot token checker doesn't read the contract's logic line by line the way a human auditor does. Instead, tools like Honeypot.is, Token Sniffer, and De.Fi Scanner simulate a buy-then-sell cycle against the contract and report whether the simulated sell transaction succeeds. Gate Learn's explainer describes Token Sniffer running this kind of swap analysis to test whether a contract actually lets a purchased token be sold back. If the simulated sell reverts, gets taxed at a suspiciously high rate, or fails outright, the tool flags the token as a likely honeypot. For a sense of how a professional review reads these same contracts in more depth, QuillAudits publishes its research and audit reports publicly.

This approach is fast, free to use, and requires no Solidity knowledge, which is why these checkers have become the default first step for retail buyers. It's also why code that behaves differently than it did during a single-pass simulation can still fool them.

Why a "Safe" Honeypot Token Checker Result Doesn't Always Mean Safe

A checker can only report on the transaction it actually ran, and several honeypot patterns are built specifically to pass that one transaction while still trapping real buyers. Three gaps come up most often:

  • Delayed-trigger honeypots. The contract behaves normally for the first several hours or days after launch, long enough for checkers and early buyers to report it as safe, then the owner flips a blacklist or tax variable once volume and liquidity have built up. The checker ran its test before the trap was armed.
  • Trading-not-yet-enabled contracts. A checker simulating a buy and sell before the owner has called the function that opens trading to the public may see both legs succeed in a permissive test environment, even though the live contract will reject every transaction from a real wallet until the owner decides otherwise, and can change the rules the moment it does.
  • Wallet-specific traps. Some honeypots only blacklist addresses that aren't on an internal whitelist, or specifically exclude the checker's own known simulation addresses from restrictions. The scanner's wallet sails through; a retail buyer's wallet doesn't.

None of this makes checkers useless. A green "safe" label is a starting signal, not a guarantee. QuillAudits' ERC-20 token contract audit review process exists for exactly this reason: it explicitly checks for hidden logic that lets users buy but not sell, tax parameters that can be raised to extreme levels later, and functions that can quietly lock or redirect user funds, the same categories a one-shot simulation can miss.

A Quick Pre-Buy Contract Checklist

Before you put real money into a new token, run through this list. It takes a few minutes and catches most of the patterns above:

  1. Run it through a checker first. Use Honeypot.is, Token Sniffer, or a similar buy/sell simulator as your baseline filter, but treat a "safe" result as a reason to keep looking, not a reason to stop.
  2. Read the contract on the block explorer. Confirm the source code is verified on Etherscan, BscScan, or the relevant chain explorer. An unverified contract is an immediate red flag on its own.
  3. Search for blacklist or whitelist mappings. Look for any mapping(address => bool) tied to a require statement inside the transfer function.
  4. Check who can change the tax rate. Find the function that sets buy and sell fees, and confirm it either has no owner-only access or enforces a hard-coded upper limit.
  5. Look for a trading-enabled switch. A boolean like tradingActive that only the owner can flip means the contract's current behavior may not be its permanent behavior.
  6. Check ownership status. Renounced ownership (the owner address set to zero) removes the ability to flip most of these switches after the fact, though it doesn't guarantee the initial logic was clean.
  7. Check liquidity lock status. Confirm liquidity pool tokens are locked or burned rather than sitting in a wallet the deployer can drain.

Why Honeypot Contracts Keep Getting Deployed

Honeypots persist because they're cheap to deploy and the regulatory and technical barriers to launching a token remain low across most EVM chains. Solidus Labs' 2022 Rug Pull Report found that 12% of all BEP-20 tokens on BNB Chain and 8% of ERC-20 tokens on Ethereum were identified as fraudulent. The same report found that nearly 2 million investors lost money to scam tokens between September 2020 and late 2022, more than the combined 1.8 million creditors affected by the FTX, Celsius, and Voyager bankruptcies.

Those numbers point to a volume problem, not an isolated-incident problem. Anyone can fork a standard ERC-20 template, add a few lines of blacklist logic, and deploy to a chain in minutes. Checker tools and manual code reviews both raise the cost of running that playbook, but neither removes the incentive, so new honeypot contracts show up daily. QuillAudits' analysis of the Labubu token exploit's transfer logic flaw is a reminder that flawed transfer functions aren't a risk confined to obvious scam tokens. They show up in live, trading contracts too.

Final Thoughts

A honeypot token checker is the right first move before buying any unfamiliar token, but it's checking one simulated transaction, not reading the contract the way a person can. The patterns that get past automated scanners, delayed triggers, trading-not-yet-enabled states, and wallet-specific whitelists, are all things a five-minute manual read of the transfer function, tax logic, and owner-only switches can catch. Run the checker, then read the code yourself before you commit. For a deeper look at the broader fraud lifecycle, read QuillAudits' honeypot scam explainer, and for the fuller process a project-level review follows, see its guide on how to audit a smart contract.

Explore more Security Decisions

Contents

Tell Us About Your Project
Subscribe to Newsletter
hashing bits image
Loading...

WE SECURE EVERYTHING YOU BUILD.

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.

QuillAudits Logo


ISO 27001Circle Alliance Program
Uniswap FoundationAethiropt-collectivePolygon SPNBNB Chain Kickstart

All Rights Reserved. © 2026. QuillAudits - LLC