A honeypot in crypto is a token you can buy and cannot sell. The honeypot contract accepts your money, then rejects the transfer that would take it back out, usually through a permission check in the code that moves tokens, or through a sell fee the owner can raise until nothing is left. A honeypot scam is the launch built around that contract: a new listing, a rising chart, and an exit only the deployer can use.
The word has two other owners, and mixing them up is how people get hurt. In network security a honeypot is a decoy server left exposed on purpose so defenders can watch attackers work. In Ethereum research it originally meant something narrower and stranger: a contract written to look broken, so that whoever tries to drain it loses their own funds instead. This page covers all three, then stays with the one that costs ordinary buyers money: how the trap works, one buy and one sell traced step by step, and how to spot it before you buy.
Quick Answer
A honeypot is a token whose smart contract lets you buy and blocks you from selling. The block usually sits in the shared transfer path as a permission check, or it is a sell fee the owner can raise to 99%. To spot one, read the verified source, run a honeypot checker that simulates a sell, and check whether anyone other than the deployer has ever sold.
Last updated September 2026.
The three things called a honeypot, and only one of them is aimed at you
The three uses share a shape. Something valuable is left where a greedy party will find it, and the person who reaches for it is the one who gets caught. What changes is who is meant to reach.
| Meaning | Who is meant to get trapped | Where you meet it |
|---|---|---|
| Network security decoy | An intruder probing your infrastructure | Enterprise security, threat intelligence |
| Classic Ethereum honeypot | Someone trying to exploit a contract | Verified source on Etherscan, security research |
| Honeypot token | An ordinary buyer | Any decentralised exchange, most often on a new listing |
The first two bait a predator. The third baits a victim and kept the name anyway, which is why a search for the word on its own turns up almost nothing about tokens. If you arrived here after a token stopped selling, the rest of this page is for you.
How a honeypot token actually blocks the sell
Almost every explanation of this stops at “hidden code blocks selling”. That is true and it is not useful, because it does not tell you where to look. Here is where to look.
When you sell a token on a decentralised exchange, you do not move your own tokens. You approve the router, and the router moves them for you, which means the call that matters is transferFrom and not transfer. Both usually funnel into one shared internal function. That shared function is where the gate goes, because a gate there catches the sell without touching the buy.
The gate sits in the shared transfer path
Reduced to its essentials, it looks like this. The deployer permits the liquidity pool and nobody else, so tokens can leave the pool (you can buy) but cannot go back into it (you cannot sell).
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
// Illustrative only. A sell-gate honeypot reduced to its essentials.
contract Trap {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) private _allowedToSend;
address private immutable _owner;
constructor() {
_owner = msg.sender;
balanceOf[msg.sender] = 1_000_000e18;
_allowedToSend[msg.sender] = true;
}
// The deployer allows the pool, and nobody else.
function setAllowed(address account, bool allowed) external {
require(msg.sender == _owner, "not owner");
_allowedToSend[account] = allowed;
}
function approve(address spender, uint256 amount) external returns (bool) {
allowance[msg.sender][spender] = amount;
return true;
}
function transfer(address to, uint256 amount) external returns (bool) {
_move(msg.sender, to, amount);
return true;
}
// Your sell arrives here, because the router moves your tokens for you.
function transferFrom(address from, address to, uint256 amount) external returns (bool) {
allowance[from][msg.sender] -= amount;
_move(from, to, amount);
return true;
}
function _move(address from, address to, uint256 amount) private {
require(_allowedToSend[from], "transfer failed");
balanceOf[from] -= amount;
balanceOf[to] += amount;
}
}
Notice the revert string. A real one says something bland like “transfer failed”, so your wallet shows a generic error and you assume the problem is slippage or gas.
A 99% sell fee is not a block, and it does the same job
The cruder version does not refuse the transfer at all. It takes the proceeds.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
// Illustrative only. The sell fee is mutable, and 9_900 basis points leaves you 1%.
contract Fee {
uint256 public sellFeeBps = 300; // 3% at launch
address private immutable _owner;
constructor() {
_owner = msg.sender;
}
function setSellFee(uint256 bps) external {
require(msg.sender == _owner, "not owner");
require(bps <= 10_000, "out of range");
sellFeeBps = bps;
}
}
A 3% sell fee is ordinary. Plenty of honest tokens charge one, and the major routers ship a dedicated swap function for tokens that take a cut on transfer. The problem is not the fee, it is setSellFee. A fee an owner can move is a fee that will be 99% on the day it matters, and a scanner that checked yesterday checked the old number.
The trap can be added after you have bought
Everything above can also be added after launch rather than written in at deployment. If the token sits behind an upgradeable proxy, the deployer can swap the implementation for a new one whose transfer path has a gate in it. The address does not change. The source you read at the token’s address does not change. The behaviour does.
A worked example: one buy, one sell, and where it fails
Two views of the same trap. The first is the code pattern above, traced by hand. The second is a real token that behaved exactly this way.
Traced through the Trap contract
This is the illustrative contract from the first snippet, not a deployed token. Four steps, and only the last one fails.
| Step | What happens | What _move checks |
Result |
|---|---|---|---|
| 1. Launch | The deployer adds supply to the pool, then calls setAllowed(pool, true) |
_allowedToSend[deployer], which the constructor set to true |
Succeeds. The pool can now pay out |
| 2. You buy | The pool pays you with transfer(you, amount) |
_allowedToSend[pool], which is true |
Succeeds. The tokens show in your wallet |
| 3. You approve | You call approve(router, amount) |
Nothing. approve never reaches _move |
Succeeds, so everything still feels normal |
| 4. You sell | The router calls transferFrom(you, pool, amount) |
_allowedToSend[you], which is false |
Reverts with “transfer failed” |
Every step before the last is an ordinary, successful transaction. The chart, the holder count and your own wallet all look healthy until the moment you try to leave. A honeypot checker exists to run step 4 for you before you buy. The example response in honeypot.is’s API documentation shows a honeypotReason of “PancakeSwap: TRANSFER_FROM_FAILED”, which is the router reporting that the transferFrom call in step 4 did not go through.
The documented case: SQUID, November 2021
SQUID is the case most people remember, and it had the behaviour this page describes. Euronews reported that “buyers found that they were unable to sell the tokens once they had bought them”. CBS News quoted CoinMarketCap’s warning that “users are not able to sell this token in Pancakeswap”, after a price that had reached $2,861, and reported that holders had been told their money sat behind “anti-dump technology”.
The numbers after the fact disagree. CBS put the operators’ take at about $3.3 million, citing an estimate from Gizmodo. Euronews reported that a wallet linked to the creators cashed out almost €3 million over the same weekend. Two outlets, two currencies, two different things being counted, which is its own lesson about how badly this gets measured.
The contract is still on BNB Smart Chain at 0x87230146E138d3F296a9a77e497A2A83012e9Bc5, and two storage reads show why the source at that address is not the whole story. We made them against a public BNB Chain node on 30 September 2026, at the implementation and admin slots defined in EIP-1967:
- The token address itself holds 735 bytes of code. It is a proxy.
- Its implementation slot points to
0xf41bd7d47c8589662e852ace26c99623fac9c05f, which holds 13,851 bytes. That is where the transfer logic lives. - Its admin slot holds
0x6bdb3b0fd9f39427a07b8ab33bac32db67eb4e38, an address with no code at all. That is an ordinary wallet: one private key able to swap the logic.
That is step 6 of the checklist below, done on a token its buyers could not sell. We read the rest of that contract in the rug pull red flags you can check before you buy.
The original honeypot: contracts built to rob the robbers
The academic meaning of the term is worth knowing, because it is where the vocabulary comes from and because it is a better story.
In 2019 Christof Ferreira Torres, Mathis Steichen and Radu State published “The Art of The Scam: Demystifying Honeypots in Ethereum Smart Contracts” at USENIX Security. They analysed more than 2 million smart contracts and found 690 honeypots and 240 victims, with over $90,000 in accumulated profit for the creators. Manual inspection confirmed 87% of the flagged contracts were genuine honeypots.
These contracts were not aimed at buyers. They were aimed at people hunting for vulnerable contracts to drain. The bait was a contract that appeared to have an obvious bug, and the trap was a second mechanism the attacker did not notice.
The paper sorts eight techniques by the layer they abuse, and the grouping is the useful part:
| Layer abused | Techniques |
|---|---|
| The Ethereum Virtual Machine | Balance disorder |
| The Solidity compiler | Inheritance disorder, skip empty string literal, type deduction overflow, uninitialised struct |
| The Etherscan explorer | Hidden state update, hidden transfer, straw man contract |
The third row is the one that still matters in 2026. Those three techniques do not exploit the chain at all. They exploit the fact that you are reading the contract through a website that does not show you everything, and that is exactly the assumption a modern honeypot token relies on when it hides behind a proxy. The most common technique in the paper was the hidden state update, at 382 of the 690.
If you want the same argument applied to code that was honest when it was written, we have made it before in when a smart contract audit actually expires.
How to spot a honeypot before you buy
In order, cheapest first.
- Check the source is verified. If the explorer shows only bytecode, you cannot read what you are buying and nobody else can either. That alone is a reason to stop.
- Read the transfer path. Find the shared internal transfer function and read every
requirein it. Look for address mappings, pause flags, maximum-amount checks and fee arithmetic. - Find the owner’s powers. Search the source for functions guarded by an owner check. Anything that sets a fee, a limit, a pause or a list is a switch that can be flipped after you buy.
- Look for a real sell. On the explorer’s token page, look at transfers into the liquidity pool from ordinary wallets. If the only address that has ever sold is the deployer, stop there, because that is the behaviour without the code.
- Simulate a sell with a honeypot checker. A honeypot checker, sometimes called a honeypot detector, simulates a buy and a sell and tells you whether the sell reverts. The honeypot.is API returns
isHoneypotwith ahoneypotReason, plusbuyTax,sellTaxandtransferTax. It also takes achainID, and without one it picks “the most suitable chain based on liquidity”, so name the chain you actually bought on. - Check who can change the code. If there is a proxy, find its admin. An upgradeable token controlled by one key is a token that can become a honeypot later.
What the scanners cannot see
Simulation checkers are genuinely useful and they are the fastest thing available. They are also a point-in-time answer to a question with a moving answer. Honeypot.is says so in its own documentation, noting that its contract-code results are “cached and may be outdated”.
Three things beat a simulation. A fee the owner raises after the check. A blocklist populated after the check. An implementation swapped after the check. A clean result means the token was sellable when the tool looked, and nothing more.
Someone reading this because a token has already trapped them wants the other half of the problem, which is watching a contract after it is deployed rather than before. That is what post-deployment monitoring is for, with detectors tuned to a protocol’s own logic instead of generic thresholds.
Honeypot or rug pull? They are not the same thing
The two get used interchangeably and they describe different mechanics.
| Honeypot | Rug pull | |
|---|---|---|
| What happens | You cannot sell | You can sell, into nothing |
| Where the trap lives | In the token contract’s transfer path | In the liquidity, which the team removes |
| When you find out | The moment you try to exit | When the price goes to zero |
| Detectable before you buy | Often, by reading the code or simulating | Harder, it depends on lock and vesting arrangements |
A honeypot is a code problem. A rug pull is a custody and incentives problem, and it needs a different checklist, which we set out in the rug pull red flags you can check before you buy. The older argument about intent, and why a failed project is not always a scam, is in when a rug pull is not a rug pull. Plenty of scams are both.
If you are building the token, not buying it
The checklist above has a cost for honest teams.
A honeypot checker cannot read intent. It reads what the contract can do, then reports a warning if a sell could fail or cost too much. Four features that legitimate protocols ship on purpose all look like that from the outside:
- A transfer fee, which shows up as a non-zero
sellTaxwhatever it funds. - Pausable transfers, which make a sell fail on the day you use them for an incident.
- A blocklist, which a regulated or sanctions-exposed token may be obliged to hold, and which is a sell gate for whoever is on it.
- An upgradeable proxy, which means the logic a checker tested today is not guaranteed tomorrow.
So the honeypot flag lands on the protocol, the screenshot travels faster than the source, and the team spends launch week explaining. The fix is to make the intent legible and the powers bounded, not to remove the features.
- Verify the source, and keep the verified source current after every upgrade.
- Document each privileged function in plain language, including its ceiling. A fee that cannot exceed 5% because the setter enforces it is a different object from a fee that can go to 99%.
- Put the owner behind a timelock or a multisig, so a change is visible before it lands rather than after.
- Publish the audit, and publish the re-audit when the code changes. A manual audit at Fidesium starts at $5,000, covers logic and economic risk line by line, and includes two rounds of fix verification.
- Keep scanning after launch. An audit describes the code on the day it was read, and a proxy makes that day expire the moment someone upgrades. Continuous scanning starts at $50 a month and runs on every commit.
A protocol that cannot show what its owner key can do is asking to be mistaken for a honeypot, and in this market that mistake is priced immediately. Our published reports are at the audit portfolio, 23 of them across 16 protocols on EVM chains and Solana, and every audit is minted as an on-chain record so the result can be checked rather than claimed.
Security is a process, and this is one of the places that stops being a slogan. Talk to the audit team if you want the powers in your token written down before someone else describes them for you.
Frequently asked questions
What is a honeypot in crypto?
A honeypot in crypto is a token whose smart contract lets you buy but prevents you from selling. The restriction is usually a permission check in the contract’s transfer path, or a sell fee the owner can raise until the proceeds are worthless. The term is borrowed from network security, where a honeypot is a decoy server used to attract and study attackers.
How do I know if a token is a honeypot before I buy?
Check that the contract source is verified on the block explorer, read every condition in the shared transfer function, and list the functions the owner can call. Then look at the token’s transfer history for sells by ordinary wallets rather than only the deployer, and run a honeypot checker that simulates a buy and a sell. Any one of these can miss a honeypot, so use several.
What does a honeypot checker actually do?
It simulates buying the token and selling it straight back, then reports whether the sell went through and what each side cost. The honeypot.is API, for example, returns isHoneypot, a honeypotReason when the answer is yes, and the buy, sell and transfer tax. The result describes the token at the moment of the check, and the owner can change it afterwards.
Can a honeypot checker be wrong?
Yes, in both directions. A checker simulates a trade at one moment, so a token can pass and then become unsellable when the owner raises the fee, adds an address to a blocklist, or upgrades the contract behind a proxy. It can also flag a legitimate token that has a transfer fee, a pause control or an upgradeable proxy for entirely ordinary reasons.
What is the difference between a honeypot and a rug pull?
In a honeypot the trap is in the token contract and you cannot sell at all. In a rug pull you can sell, but the team has removed the liquidity so there is nothing to sell into. A honeypot is a code problem you can often detect by reading the contract. A rug pull is a custody and incentives problem, and many scams are both.
Why does a search for honeypot return so little about crypto?
Because the word had other meanings long before tokens existed. In network security a honeypot is a system deliberately left exposed so defenders can observe how attackers behave. The crypto meaning reuses the word for something close to its opposite, a trap set for ordinary buyers rather than for intruders.
Are honeypot contracts illegal?
Deploying a contract designed to take money from buyers who cannot sell is fraud in most jurisdictions, whatever the code does. Enforcement is a separate question from legality, and cross-border recovery is difficult. Treat prevention as the only reliable control, because funds that leave a wallet in this way are rarely recovered.
Can an audit tell me a token is safe?
No, and no honest auditor will tell you otherwise. An audit reports what was found in a specific version of the code at a specific time, including who holds privileged powers and what those powers can do. It cannot promise that nothing was missed, and it says nothing about a version of the code deployed afterwards, which is why continuous scanning exists alongside it.
What should I do if I am already holding a honeypot token?
Stop adding to the position, and do not pay anything to a service promising recovery, because those are usually a second scam aimed at the same victim. Record the contract address and your transaction hashes, report the token to the explorer and to the aggregators listing it, and check whether the exchange you used has a fraud process. Assume the funds are gone while you do this.



