Building a Token Safety Gate That Blocked 6 Honeypots in 3 Weeks

The Problem

Memecoin trading is full of traps. Most tokens look clean at first glance. Green candles. Normal holder count. Nothing weird on DexScreener. Then you ape in and discover the contract won’t let you sell. Welcome to a honeypot.

Your money’s locked. The dev usually rugs right after.

I built a safety gate for this. A small bot that screens tokens before any buy order goes through. Over three weeks it scanned around 50 of them. Six were honeypots. Without the gate, the bot would’ve eaten those losses without blinking. That was the whole reason I built it.

The hard part wasn’t catching obvious scams. Plenty of tools do that. The real headache was false positives. Too aggressive and you start skipping legit tokens with weird tokenomics. Too loose and you’re buying garbage again. I spent more time tuning the heuristics than I did writing the original logic.

The Safety Gate

Scoring System

Threshold: 60/100 to pass. Anything 59 or below gets rejected on sight.

The tradeoff is real and I’m fine with it. A legit project that launches with thin liquidity gets dropped into the reject pile right next to the scams. I’d rather miss a 10x than lose the bag to a honeypot. That’s the deal I made when I built it, and I’d make it again.

How It Works

The gate pulls from DexScreener’s free API. One endpoint does the heavy lifting:

GET https://api.dexscreener.com/latest/dex/tokens/{mint_address}

Responses come back fast. Usually under 300ms. You get:

• Liquidity depth across every pair
• 24h volume and tx counts
• DEX listings
• Social links when they exist
• Pair creation timestamp

I weight each factor, sum them into a score, and anything below threshold gets blocked. Runs on autopilot. No waiting on me to hit approve.

Now the part nobody likes talking about: tradeoffs. The free tier rate limits bite hard if you’re scanning lots of mints. I cache responses for a few minutes in n8n so I’m not hammering the endpoint. You’ll also get false positives. A legit launch with thin liquidity looks exactly like a honeypot in the first few hours, and there’s no API field that separates them yet. I’d rather block a good token than let a bad one drain the wallet.

Real Results

Three weeks in. Here’s what the gate blocked.

What stayed in my wallet: the full $93 I’d earmarked for trades. Honestly, most of these were obvious in hindsight — thin liquidity, fresh contracts, names that screamed scam. The gate catches the dumb ones. The clever tokens that look legit at first glance? Still on me to catch.

The False Positives

The gate runs conservative. That’s on purpose, but it means some real tokens get caught in the net.

What gets flagged:

• New tokens under 48h old. The age penalty hits them hard.
• Niche community tokens. Thin liquidity, but loyal holders.
• Post-dump recovery tokens where the sell ratio stays skewed for days after the dump.

I’ve overridden two manually. Both turned out legit. One was a meme coin with an 800-person Telegram that hadn’t even launched yet. That one stung because the community was clearly real.

Rule I landed on: the gate is a filter, not a verdict. Anything scoring 45-59 pings me on Discord and I decide. Under 45 gets auto-blocked without a second look.

Integration

The safety gate sits in front of the buy executor inside the TradeBot daemon. Here’s the flow:

1. Scout spots a buy signal
2. Safety gate pulls token data and scores it
3. Score under 60? BLOCKED, logged to the Discord failures channel
4. Score 60 or higher? Passes through to execution
5. Score 45-59? Pauses and pings me for manual approval

I picked 60 as the hard cutoff. Anything below it I wouldn’t touch manually anyway. The 45-59 band is where the weird-but-not-obviously-scammy tokens land, and those are worth a second look.

Latency added: about 300ms per trade. The fetch is what slows it down, not the scoring. It triples the path length, but the bot holds positions for days, so the extra time doesn’t matter to me.

Building Your Own

You don’t need my exact code. Here’s the stripped-down version that captures the idea.

python
import requests

def check_token(mint):
r = requests.get(f”https://api.dexscreener.com/latest/dex/tokens/{mint}”)
data = r.json()[‘pairs’][0]

score = 0
score += min(data[‘liquidity’][‘usd’] / 1000, 25)

liquidity

score += min(data[‘volume’][‘h24’] / 10000, 20)

volume

… etc

return score

This isn’t a complete safety system. It catches obvious red flags and misses the subtler ones. That’s the tradeoff: speed and simplicity over depth. If a loss would actually sting, layer something else on top.

Weight it for your own situation. Mine leans conservative because the portfolio is small. Trading bigger? Crank the thresholds and add more checks before you trust it.

What’s Next

The gate works. It’s not finished, though. I’ve got a few things I want to bolt on over the coming weeks.

1. RugCheck.xyz integration. Deeper contract analysis so I can catch tax tokens and active mint authority before they hit the wallet check. Right now those slip through if I don’t manually verify.
2. Historical scoring. Store scores over time so a token that was clean last month but went sideways this week actually gets flagged. Tokens rot. The gate only sees what’s in front of it, and that’s a real blind spot.
3. Community data. Pull in scam reports from a few traders I trust. One pair of eyes misses stuff. Ten pairs don’t, though I need to be careful about signal versus noise there.

I’ll write it up when each piece lands. If you’ve got a data source I should be pulling from, my DMs are open.

The Lesson

Automation without guardrails is gambling. I figured that out after the third rug pull in a month. The safety gate doesn’t make memecoin trading safe. Nothing does. But it turns “I saw a green chart on DEXTools” into something closer to a calculated bet than a coin flip.

I built this because I was tired of getting wrecked. Not financially ruined, just annoyed. Every few weeks I’d ape into something that looked clean, only to find out the liquidity was locked for 48 hours, or the top 10 holders owned 94% of supply, or the contract had a blacklist function nobody mentioned. Stuff a 30-second check would’ve caught.

The tradeoff: it spits out false positives sometimes. New legit tokens with locked liquidity for a few days get flagged. Annoying, but I’d rather miss a runner than get rugged again.

Want the full safety gate code? It’s in the TradeBot automation package ($25). Scoring algorithm, API integration, Discord reporting.

—

Not financial advice. This is a security tool I built because I was sick of losing money to obvious traps. Use at your own risk. Verify everything yourself before you ape.