_{The home page on Oct 13: paste any token, or scan it in Telegram; below, live tiles for Launch Radar, Track Record, AI agents and Jev.}

$CRAWLHIVE (Solana): D4jNDQa3Cu4v8VMCAc2z7pgGGo7aGqzjXmwGR9wapump
_{The only official contract. The treasury buys it back and burns it every 12 hours: crawlhive.xyz/#treasury · pump.fun · DexScreener}

Memecoin alpha is scattered: a KOL post on X, a coordinated call in a Telegram group, a whale wallet buying a fresh pool. Nobody can watch all of it, and one bot only sees what its owner told it to watch.

CrawlHive gives everyone their own crawler. Spawn one, point it at the sources you know best (X accounts, Telegram channels, new on-chain pairs, project docs) and tell it in plain words what to hunt for. It crawls on a schedule, an AI reads everything through your instructions, and the matches come to you privately: on the site and in Telegram. Every signal that names a token is checked against the real price later, so you see which of your crawlers is actually right.

All crawlers live on one public swarm map with a reputation score. After the project token launches, proven crawlers can be sold or rented, and holders will vote on what the swarm should dig into.

In one line: you bring the edge, your crawler does the watching, the scoreboard shows who was right.

Latest (Oct 13):

• 🔥 $CRAWLHIVE: buyback & burn, Crawler of the day. The home page shows the token with a live chart. Every 12 hours (00:00 and 12:00 UTC) the treasury buys $CRAWLHIVE with what crawler spawns earned, and the bought tokens are burned in the same transaction; every burn is listed with its transaction. Half of the day's creator fees go to the owner of the best crawler of the day, if they hold $CRAWLHIVE.
• 🩻 Contract X-Ray: we reverse engineer every token. On BNB Chain and Robinhood Chain the scanner reads the deployed bytecode, even when the source is not published, traces which functions write what with evmole (the EVM engine of the REA reverse-engineering toolkit), and lists what the team can still do to holders: mint, blacklist wallets, change the tax, stop trading, cap sells, upgrade the contract through a proxy. On Solana it reads Token-2022 extensions: permanent delegate, transfer hook, transfer tax, frozen-by-default, pausable. The project website is checked for wallet-drainer code. Every power counts against the score, and AI agents get the same X-Ray through MCP.
• 🔐 Security audit. Several agents went through the whole codebase in parallel, every finding was verified by hand, and more than a dozen issues were fixed: SSRF-safe fetching for docs targets, a ReDoS fix, real client IPs in limits, domain-bound wallet sign-in with logout everywhere, OAuth hardening, a verdict floor against prompt injection, a separate AI budget for anonymous Telegram scans, and a non-root container. Details in Trust & safety.
• 💬 Bot: welcome banner, inline and support. /start greets you with a banner, @crawlhivebot <address> works inline in any chat, and /support sends your message to the team, with the answer coming back in the same chat. Group settings can be changed by group admins only.
• 🟡 BNB Chain and Meteora. Scans now cover BNB Chain tokens (holders, honeypot, contract owner, four.meme bonding curve) and every Solana launchpad: pump.fun, Meteora, Raydium LaunchLab and others get their curve detected and their creator wallet traced. A 0x address finds its chain by itself.
• 📱 CrawlHive is now an app inside Telegram. Open @crawlhivebot and press Open app: scan tokens, browse Launch Radar, manage your watchlist and alerts, and see your crawlers and their signals, with no install and no sign-up.
• 🎯 Track Record. Every verdict, from user scans, crawler safety checks, Launch Radar and agents, is checked against the real price for 24 hours. The page shows how many DANGER tokens dumped, and how many CLEAN / OK tokens dumped anyway: hits and misses, nothing hidden. crawlhive.xyz/track
• 📡 Launch Radar. The swarm scans fresh launches on Solana, Robinhood Chain and BNB Chain on its own and publishes the verdicts with a 10-minute delay; crawler owners get them live. crawlhive.xyz/radar
• 🤖 Telegram bot for everyone. Send a token address, link or $TICKER and get the scan in the chat. Tap 👁 Watch, and for 7 days the bot pings you if liquidity is pulled, the price falls 50% or the verdict turns DANGER. /radar shows fresh launches.
• 🤝 Any agent, one click. OpenAI has Dots, SpaceX has Grok Bot, Meta has Muse: all of them can now run your crawlers. ChatGPT Dots, Meta Muse, Claude and Cursor connect with a Connect button (OAuth): no key to copy, you pick the bot and the crawlers on CrawlHive and approve with your wallet.

Oct 12:

• ⚡ Jev decides, Grok researches. Jev, a decision model, rates every crawler find in about half a second, for about $0.00002 per decision. Pure noise and scams are skipped before the safety scan, and the rest are checked most-promising first. The Grok Bot's LOOK / WATCH / AVOID comes from Jev when it is at least 70% sure, and Grok is asked only about the doubtful ones. Each signal shows its Jev rating.
• 🐙 Grok Bot on duty. One switch under a crawler: the bot reads every new signal and answers LOOK, WATCH or AVOID. It sleeps while nothing happens, and a wake-up costs about $0.001.
• 🔌 Bring your own agent. Grok Bot, Claude or Cursor can plug into your crawlers through our MCP server. Tested live with the Grok API.
• 🛡 Every signal is safety-checked. Each token a crawler finds is scanned first, and rugs never reach you.
• 📈 Fair scoring. The price is sampled every 5 minutes, and a hit counts the best moment in the window.
• 💸 Cheaper to run. Free scans no longer touch Grok, and an X check went from about $0.40 to $0.05.

No wallet, no sign-up. Paste a token address, a DexScreener / pump.fun link or a $TICKER on crawlhive.xyz and press crawl. Works for Solana and Robinhood Chain tokens: addresses pick their network by themselves, and a toggle under the box says where to look up a $TICKER. The crawlers run in parallel and you watch them work in a live tail -f crawler.log:

Chains and launchpads. Solana (pump.fun, Meteora DBC, Raydium LaunchLab, Moonshot and any other curve), Robinhood Chain and BNB Chain (including four.meme). A token still on a launchpad curve is reported as on the curve, not as a pool with $0. On Solana the creator comes from the pump.fun curve when there is one; for every other launchpad it is the wallet that paid for the token's very first transaction (up to 25 pages of history, 9 seconds). On the EVM chains holders, top-10 share and the honeypot flag come from GeckoTerminal and the contract owner from the chain's RPC (BSC_RPC_URL overrides the public BNB endpoint). A 0x address is looked up on every supported EVM chain and the most liquid pair wins, unless you picked a chain.

They return a 0–100 score (CLEAN / OK / RISKY / DANGER, or TOO EARLY for pairs under 30 minutes) with a one-line reason, a shareable page (/scan/<address>), and a Watch 30 days button that turns the one-off scan into a crawler watching that token for you.

_{Instant Crawl on dogwifhat: the original $WIF among 10 tokens with that ticker, mint renounced, no freeze, scored CLEAN.}

Who's talking on X. Once Grok finishes, the scan shows a map of the people who posted about the token: the crawler in the middle, authors around it on orbits, the ring colour is the stance of their post (bullish, bearish, neutral); bigger accounts sit closer to the centre and get bigger bubbles. Tap a bubble to read the post and open it on X. Only posts Grok actually found are shown: every link is checked against its search citations, and the handle is taken from the post URL. Avatars and follower counts come from the public profile (via the fxtwitter API, cached for a day), with a letter when there is no avatar.

Share a result. Every scan gets its own page, crawlhive.xyz/scan/<address>, with a preview card generated for that token: score ring, verdict, the main reason and the worst flags. Share on X opens a ready post with the link, so the card shows up right in the feed.

Creator history. For pump.fun tokens the bonding curve account stores the creator's address. One getProgramAccounts call filtered by that address returns every curve the creator has made, with its graduated flag, so the scan knows the track record without any third-party API. Ten or more earlier launches with none graduated score as Serial launcher (−25); a weak record, a creator wallet under a day old or a creator still holding over 10% cost points too, and a creator whose launches often graduate earns a few. Example: a token whose creator had launched 28 others, none of which graduated.

Robinhood Chain. Paste a 0x… address (or a $TICKER with the Robinhood Chain toggle on) and the scan switches to EVM checks. Robinhood Chain has no mint or freeze authority, so crawler_holders checks what plays that role on EVM: whether the deployer still owns the contract (an owner can often change fees, pause trading or mint; renounced means nobody can), the holder count and top-10 share from GeckoTerminal, and GeckoTerminal's honeypot flag (you can buy but not sell, −60). Market, copycat tickers, Telegram and the X map work the same as on Solana. Wrapped ETH, USDG and bridged USDC are core assets.

Copycats are always younger. A token with the same ticker and a much bigger FDV only counts as "the original" if it listed no later than the scanned one. Fresh clones with inflated FDV (two $BONK copies with a ~$2B FDV appeared in 2025) no longer make the real token look like a copy.

Core assets. Wrapped SOL, USDC, USDT, JUP, JitoSOL and mSOL are recognised as core Solana assets: holder, copycat and bundle checks are skipped for them, since hundreds of tokens borrow their tickers.

Bundle detection. Pools and pump.fun curves are program accounts and are skipped; funders holding over 5,000 SOL are treated as exchanges, not links. Five or more linked top wallets (or 10%+ of supply) score as Bundled. Example: a 1-hour-old pump.fun token whose 12 top wallets were all created by one signer.

_{12 top wallets share one funder → Bundled. The X panel summarizes what call accounts and scanners post about the token.}

_{crawlhive.xyz: real crawlers only, no simulated network. (The octopus-spider crawls around the site; poke it.)}

_{The same map in demo mode (local runs): every dot is a crawler (colour = source, size = reputation), hexagons are the wallets that spawned them, dots flash when they fire a signal.}

The map sits on a honeycomb grid that pans and zooms with it. While the swarm is small, every crawler is labelled with its name, source and tier, every wallet with how many crawlers it runs, and the view zooms in so nothing gets lost; dashed links with a running spark show which wallet spawned which crawler.

flowchart LR
    A["👤 You<br/>sources + instructions"] -->|"pay in SOL or ETH<br/>30 days"| B["🕷 Crawler"]
    B -->|"crawls X · Telegram<br/>on-chain · docs"| S["🛡 Safety scan<br/>rugs blocked"]
    S --> C["⚡ Private signals"]
    C --> T["📬 My Signals<br/>& Telegram"]
    C -.->|"optional"| GB["🐙 Grok Bot<br/>look · watch · avoid"]
    C -->|"best price in your window"| E["⭐ Hit / miss<br/>Reputation"]
    E --> G["🏆 Leaderboard"]
    B -->|"renew any time"| B
    B -.->|"after token launch"| H["🛒 Marketplace · 🗳 Governance"]

1. Spawn. Choose a tier, a source, a chain (Solana, Robinhood Chain, Base, Ethereum), up to three narratives and your targets. Write your crawler's specification: plain-language instructions, keywords, filters, and what counts as a hit. Pay in SOL from Phantom, or in ETH on Robinhood Chain from MetaMask or Rabby. A payment buys 30 days of crawling.
2. Crawl. Your crawler sweeps its targets on a schedule: X through Grok search, public Telegram channels, DexScreener, or any web page. An AI reads what it finds through your instructions, and every token it picks out is safety-scanned before it becomes a signal.
3. Get your signals. Signals land in your private My Signals inbox and, if you connect the bot, in your Telegram DMs, with links to the source. Nobody else sees their content.
4. See who was right. Every signal with a token is tracked against the real price through your horizon: a hit if it reached your target, a miss if it did not. Precision, uptime, data volume and stake make up the crawler's reputation.
5. Renew. Three days before the term ends the bot reminds you. One click on the crawler page adds another 30 days; an expired crawler simply pauses until you renew.

Full specification format, sources and limits: docs/CRAWLERS.md.

Don't want to write a specification? The marketplace has nine crawlers with sources and rules we tested: Fresh Pair Hunter, Robinhood Chain Radar (new Robinhood Chain tokens from DexScreener), Boost Radar, AI Agent Scout (DexScreener), Pump.fun Buzz, Whales & Listings (Telegram), KOL Call Tracker (X via Grok), Ecosystem Watch and New Coins Lister (page changes). Buy is a regular on-chain spawn with the template's settings at the tier price; the slider icon opens Spawn prefilled so you can change anything first. Each card shows how many copies are running.

Every crawler you spawn gets a specification: what it should look for, written in plain language, plus filters and a scoring rule. An AI (Grok) reads every new post, message, token or page through those rules and only sends you what fits.

_{Writing the specification while spawning: instructions, keywords, signal types, minimum confidence, on-chain filters and what counts as a hit.}

Signals are yours alone. They land in My Signals with links to the source and the safety verdict, and each one that points at a token is tracked against the real price through your horizon: a hit if it reached your target, a miss if it did not. Other users only see that your crawler fired.

_{My Signals: a real on-chain crawler's output. 10 signals scored against DexScreener prices 15 minutes later, 5 hits.}

_{A live crawler's page as its owner sees it: crawl status, editable specification, reputation breakdown, private signals.}

Under the hood, every signal is checked before it reaches you:

• Safety gate. Each token a crawler finds on Solana or Robinhood Chain goes through the Instant Crawl scan first (market, holders, bundles, creator history, honeypot and owner on Robinhood). DANGER never reaches you; every other signal carries its verdict and a link to the full scan. The most confident finds are checked first; whatever does not fit into a run's scan budget waits for the next run instead of going out unchecked. If a scan fails, the signal waits one run; only a second failure in a row lets it through without a verdict.
• Fair scoring. The price is sampled every 5 minutes while a signal is in its window. A hit means the token reached your target at any point in the window, not only at the last minute, and every scored signal shows its peak and drawdown.
• Smarter repeats. Duplicates are muted per token and signal type, so a whale buy after a new-pair alert still gets through.
• Backoff. When a source keeps failing, each next try waits twice as long, up to an hour, instead of hammering it.
• RPC limiter. All Solana RPC calls share one rate limiter with retries on 429, so a rush of scans no longer starves the checks.

What each source reads and how signals are scored: docs/CRAWLERS.md.

• Buyback & burn. The treasury that collects spawn payments buys $CRAWLHIVE every 12 hours. One transaction does both: a Jupiter swap SOL → $CRAWLHIVE (routes through the pump.fun curve too) and an SPL BurnChecked of the guaranteed minimum output, plus a crawlhive:buyback memo. The transaction is built by the server but signed by the treasury wallet in Phantom: the server never holds the treasury key, and only a signed-in treasury session can request one. After it lands, the server reads it from the chain (success, signer, burn of the mint, SOL spent, tokens burned) and adds it to the public list. Leftover dust above the minimum can be burned with one more click. The team gets a Telegram reminder when each 12-hour window opens.
• Crawler of the day. Every UTC day the crawlers are ranked by how their token signals played out: a peak of 2x or more earns its multiple in points, a dump of 50% costs a point. The winner's owner must hold $CRAWLHIVE (REWARD_MIN_HOLD). Half of the day's creator fees are paid to them in SOL, again signed in Phantom and verified on-chain (crawlhive:reward:<day> memo), and shown as the last winner.
• Contract: D4jNDQa3Cu4v8VMCAc2z7pgGGo7aGqzjXmwGR9wapump (Token-2022, launched on pump.fun). In Telegram /token (or /ca) shows it with buy and chart buttons.
• Config: TOKEN_MINT / TOKEN_SYMBOL turn on the token block, buybacks and the holder check; REWARD_MIN_HOLD, CREATOR_WALLET configure rewards. Code: src/lib/server/buyback-tx.ts, buyback.ts, rewards.ts, src/components/token-panel.tsx, buyback-burn.tsx.

Under buyback & burn on the home page (and from the 🚀 buttons in the menu and the hero) anyone with Phantom can chip in 0.05–1 SOL, or pay the whole current level at once, toward $CRAWLHIVE on DexScreener. The fund climbs a ladder: DEX paid (Enhanced Token Info, $299), then Boost 10x ($99), Boost 30x ($249), Boost 100x ($899) and the Golden ticker (500x, $3,999); prices are DexScreener's as of October 2026 and can be changed with DEX_LEVELS. A level paid outside the fund (the profile, paid on launch day) is listed in DEX_PAID_ELSEWHERE: it shows as paid and its price is not taken out of the gifts, so every donation goes to the next boost. The server builds one transaction (a SOL transfer to the treasury plus a crawlhive:dexfund memo), Phantom signs and sends it, and the gift is counted only after the server finds the transfer onchain. Raised SOL is held apart from buybacks; a level counts as spent once DexScreener's public orders API shows it bought, and the fund moves on to the next level, so the button never disappears. Code: src/lib/server/dexfund.ts, src/components/dex-fund.tsx.

Closed-source contracts are where the traps hide, so the scanner reads the code itself.

• EVM (BNB Chain, Robinhood Chain). eth_getCode, then a proper opcode walk (push data skipped, metadata tail cut) collects the function selectors from the dispatcher. They are matched against 134 dangerous signatures (selectors computed with keccak at load, none typed by hand) grouped into powers: Can mint, Can blacklist, Tax can change, Can seize balances, Can stop trading, Sell limits, plus low-weight launch mechanics (enable trading, remove limits, tax-free wallets). EIP-1967, beacon, EIP-1167 and legacy OpenZeppelin proxies are detected and the implementation is read too: an upgradeable contract is flagged Upgradeable, with the admin. SELFDESTRUCT is flagged. If ownership is renounced and no role-based access (grantRole, authorize) exists, owner-only powers are shown as dead and don't count. Unknown functions are counted, never guessed.
• Behaviour, not just names (evmole, the EVM engine inside REA). Scammers rename their functions, so a name table alone misses them. The bytecode also goes through evmole (MIT, WASM, about 30–500 ms per contract), the engine that the REA "reverse engineer anything" toolkit uses for EVM: it recovers every function with its argument types and mutability, plus the storage layout, meaning which functions read and which write each slot. From that the scanner infers levers the name table can't see: an unrecognised function that sets a per-wallet flag every transfer checks, a setter for a number every transfer reads (tax, limit, threshold), a function outside the known mint/burn that writes the total supply. Candidate names are looked up in the open signature database (openchain): a pool list (setAutomatedMarketMakerPair) is told apart from a block list, initializers are skipped, and a function named like a standard ERC-20 call with different arguments (Approve(address[])) is flagged as a Disguised function, a classic honeypot trick. Inferred findings say so, and an unnamed flag is only reported as a possible hidden blacklist. We use REA's engine rather than REA itself: its website module needs a full Chrome executing the site's code on the server, which bypasses our SSRF guard and costs about 1.5 GB of RAM per scan.
• Solana. Classic SPL tokens have nothing to read beyond mint and freeze authority. Token-2022 mints are unpacked: Permanent delegate (one wallet can move or burn anyone's tokens), Transfer hook (the team's own program runs on every transfer, and can block sells), Transfer tax with its current rate and whether the authority can change it, New wallets start frozen, Can pause all transfers, Can't be transferred, confidential transfers.
• Project website. The site listed on DexScreener is fetched through the SSRF-safe fetcher (page plus up to 8 scripts, analytics skipped) and checked for drainer behaviour: unlimited approvals to a hard-coded spender, Permit2 / Seaport order signing, Solana signAllTransactions with transfers to a hard-coded address, known drainer kits and Telegram-bot loggers, heavy obfuscation next to wallet code. Scripts are parsed into a syntax tree with @babel/parser (the same parser REA uses for JavaScript), never executed: the check looks for an actual approve / increaseAllowance call with an unlimited amount, a setApprovalForAll(…, true), a wagmi-style writeContract({ functionName: "approve", args: [...] }), raw 0x095ea7b3 approve calldata, or a Solana SystemProgram.transfer / createTransfer…Instruction / createSetAuthorityInstruction, where the spender or recipient is a hard-coded address (followed through const SPENDER = "0x…" and new PublicKey("…")). Known routers (Uniswap, PancakeSwap, 1inch, 0x, Permit2, Seaport) don't count. A string in a library ABI next to an unrelated address no longer looks like a drainer. Files too large or broken to parse fall back to pattern rules, and obfuscated bundles keep their own rule. The rules need several signals together and were tuned on real sites (pump.fun, Uniswap, Raydium, Jupiter, OpenSea, meme sites) so that legitimate dapps don't fire.

Each finding becomes a scored factor (for example Can mint −25, Permanent delegate −35, Drainer signs −40), shows up in the 🩻 Contract X-Ray panel on the site, in the Telegram app and on the bot's scan card, and is returned to agents as contractXray by the MCP scan_token tool. Code: src/lib/server/scan-xray.ts, scan-t22.ts, scan-site.ts.

Track Record (/track) answers the only question that matters about a scanner: did the verdict come true? Every verdict is stored with the price and liquidity at the moment of the scan, whether it came from a user scan, a crawler's safety check, Launch Radar or an agent through MCP. For the next 24 hours the price is sampled every 10 minutes. A token counts as dumped when its low falls 50% below the scan price, and as rugged when its liquidity drops below 20% of the start or the pair disappears. One token counts once per day, and a real verdict replaces an earlier TOO_EARLY. The page splits the outcome by verdict, lists the DANGER calls that came true (We warned you) and the CLEAN / OK calls that dumped anyway (We missed), and shows the hit rate of crawler signals without revealing their tickers.

Launch Radar (/radar) is the swarm scanning on its own. Every 3 minutes it takes new DexScreener profiles and boosts on Solana, Robinhood Chain and BNB Chain, keeps launches between 36 minutes and 24 hours old with at least $5k liquidity, and runs the full Instant Crawl scan on up to four of them (no X search, so no Grok cost; 500 scans a day at most). Everyone sees the verdicts 10 minutes later; crawler owners get finds like these the second they appear, filtered to their own rules.

Every 15 minutes all new verdicts and crawler signals are hashed into a Merkle tree, and its root is written to Solana in a Memo transaction signed by one public notary wallet. Once a root is onchain, no record in that window can be changed or deleted after the price moves: the root would stop matching. Anyone can check a record on /track: find it by token address or signal id, and the browser recomputes the leaf and the path with WebCrypto and reads the memo straight from a public Solana RPC, so you don't have to trust our server.

Private crawler signals are committed as a salted hash of their content, so their tokens stay hidden until the owner reveals them. What the proof does not show: that a record was never left out before its window closed. Code: src/lib/server/proof.ts, src/components/proof-card.tsx.

Open My Signals, press Connect Telegram and hit Start in the bot chat. The site gives you a one-time link (valid 15 minutes) that ties your wallet to that chat; nothing else is shared. From then on every new signal from your crawlers arrives as a DM with the ticker, contract address, confidence, source links and a link back to the crawler. /status shows linked wallets, /stop unlinks.

CrawlHive app in Telegram (Mini App). The bot's menu button opens a full app at /tg, built for a phone, with five tabs: Scan (paste or one tap from the clipboard, live crawler log, score ring, every flag with its weight, Watch / Share / Full report), Radar (fresh launches the swarm scanned), Watch (watchlist with the live price since you started, Launch Radar alert filters, 24-hour follow-ups), Crawlers (your crawlers and their private signals, Jev ratings, Grok Bot takes and outcomes, once your wallet is linked to Telegram) and Track. The user is identified by Telegram's signed initData, checked on the server on every request (HMAC with the bot token, 24 hours max), so there is no sign-up. The app and the bot share the watchlist and settings. It follows Telegram's theme, vibrates on a verdict and uses Telegram's back button. Illustrations were made for the app with Higgsfield.

@crawlhivebot in chats and groups, wallet or not:

The menu keeps only two commands: /start (a banner and "send me a token") and /support, which forwards your message to the team; answers arrive in the same chat. Everything else still works: /scan, /radar, /alerts, /watchlist, /unwatch, /track, /settings, /followups, /status, /stop.

Admin dashboard. For the team, /admin in the bot opens a dashboard inside the Mini App (/tg/admin): Telegram users (total, active and new in 24 hours, app opens, scans, linked wallets), site traffic and blocked requests, verdicts by source and radar scans, crawlers (live, active, failing with the last error), payments and both treasuries, Grok and Jev spend against their daily limits, connected agents, watchlists and alert subscriptions, and the open support inbox. /reply <user id> <text> answers a support message. Access is checked on the server against TELEGRAM_ADMIN_IDS / TELEGRAM_ADMIN_USERNAMES using the signed initData; everyone else gets 403.

One switch, no setup. Every live crawler in My Crawlers has a Grok Bot on duty switch. Turn it on and our own Grok Bot reads each new signal from that crawler: it waits 20 seconds to batch what arrived together, runs the Instant Crawl scan on the tokens (up to five per wake-up), and writes one line under every signal: LOOK, WATCH or AVOID, with the reason and a link to the scan. The same line follows the signal to Telegram. It never polls: no signals, no calls, nothing spent. A wake-up costs about $0.001 (one Grok call for the whole batch, no X search), capped at 40 wake-ups per crawler per day; if the Grok budget runs out, the line comes straight from the scan verdict instead.

Bring your own agent. Already run a Grok Bot, ChatGPT Dots, Meta Muse, Claude or Cursor? Put it on duty over your crawlers. Open My Crawlers, press Connect a bot, pick one crawler, two, or the whole family, and you get a key for the CrawlHive MCP server. On the swarm map every crawler with a bot over it turns into our octopus with a Grok Bot face; its eyes blink while the bot is connected.

The point is cost. An agent that wakes up every few minutes to look at a feed burns credits on runs where nothing changed. Your crawlers already watch X, Telegram and the chain around the clock, so the bot calls whats_new first and goes back to sleep when the answer is changed: false.

Connect any agent. Two ways in:

With OAuth the agent registers itself (RFC 7591), opens crawlhive.xyz/oauth/authorize, and you pick an existing bot or create a new one over the crawlers you choose, then approve with your wallet. PKCE (S256) is required, codes are single-use and live 10 minutes, access tokens last 30 days and refresh tokens rotate on every use. Every connected app shows on its bot card in My Crawlers and can be disconnected on its own; deleting the bot revokes its key and all its tokens. Metadata: /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server.

Server: https://crawlhive.xyz/mcp (Streamable HTTP, JSON responses). Without credentials it answers 401 with a WWW-Authenticate link to the OAuth metadata, so clients start the sign-in on their own. With a key: header Authorization: Bearer chb_…; clients that take only a URL can pass ?key=. A bot sees only the crawlers you picked, cannot change them and cannot move funds. Keys are stored as hashes and shown once; disconnecting a bot revokes its key at once. MCP calls never trigger a Grok search on our side, and scan_token is limited to 20 per hour per bot. Bots are an add-on: crawlers, signals and Telegram delivery work the same without one.

_{A crawler with a Grok Bot on duty turns into our octopus with a Grok Bot face. Legs take the colour of its source (X, Telegram, on-chain, docs); it glows and blinks while the bot is connected; a badge counts several bots.}

One switch per crawler in My Crawlers (test data).

The bot's line under each signal: take, scan verdict, reason, link to the scan (test data).

No account, no bot key: any AI agent with a Solana wallet can buy a scan per call in USDC over x402, the open HTTP 402 payment protocol (v2, with v1 clients understood too).

The first request answers 402 with the requirements in the PAYMENT-REQUIRED header (and the v1 object in the body): exact scheme on solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp, native USDC, our receiving address, the facilitator's fee payer. The agent signs the USDC transfer and repeats the request with PAYMENT-SIGNATURE; the answer carries PAYMENT-RESPONSE with the Solana transaction. The order is verify → scan → settle: the payment is checked first, the money moves only after the scan succeeds, so a failed scan costs nothing. Fees are paid by the facilitator (PayAI, no API key); the server holds no private key and never sends funds, USDC goes straight to the receiving wallet. Amount, recipient and network are taken from our own requirements, never from the client's header; one signed transaction pays for one call; q and chain are checked before any payment is asked; paid calls are limited per wallet and per IP; the X check answers 503 before payment when today's Grok budget is used up.

curl -i "https://crawlhive.xyz/api/x402/scan?q=%24BONK"     # 402 with the price

import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactSvmScheme } from "@x402/svm";
import { createKeyPairSignerFromBytes } from "@solana/kit";

const signer = await createKeyPairSignerFromBytes(secretKeyBytes);
const pay = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", client: new ExactSvmScheme(signer) }],
});
const scan = await (await pay("https://crawlhive.xyz/api/x402/scan?q=%24BONK")).json();

Code: src/lib/server/x402.ts, src/app/api/x402/. Paid calls and USDC earned show on the admin dashboard.

curl -s https://crawlhive.xyz/a2a -H 'content-type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"SendMessage","params":{"message":{"role":"ROLE_USER","messageId":"1","parts":[{"text":"scan $BONK"}]}}}'

Jev is a decision model from TypeSafe. It does not write text: it picks an answer from options we define and returns a probability. We call it through OpenRouter in two places:

Measured on production: about 0.5–0.7 s and $0.000017 per decision. On the 15 latest real signals Jev rated hits 66–83% and the weakest movers 49–55%, and skipped none of them. Spam like "FREE AIRDROP, connect wallet" scored 3%. Without OPENROUTER_API_KEY the layer is off and crawlers work as before.

_{Design concept: a crawler running Jev gets pink leg tips and the spark on top; a Grok Bot with Jev gets a pink pearl face with the spark on its forehead.}

_{Live on production, Oct 12: Fresh Pair Hunter (on-chain, Larva). Every new signal carries its Jev rating next to the crawler's confidence. Signal text is private to the owner, so the public page shows only the kind, the rating and the outcome. In its first hour Jev rated 29 real signals for $0.0008 in total, 440–570 ms each.}

We tested the whole loop with the Grok API: with three fresh signals Grok called whats_new, scanned each token and reported which to look at and which to avoid ($0.006); on a quiet check it stopped after the first call ($0.0006).

A routine to paste into Grok Bot:

Every hour: call CrawlHive whats_new.
If changed is false, stop.
Otherwise run scan_token on every token in the new signals
and send me only those with verdict CLEAN or OK, with the scan page link.

CrawlHive is an MVP. We'd rather you know exactly what is live than find out later.

Spawn. Tier, source, narratives, targets, frequency. Price is paid in SOL through Phantom.	Crawler page (public view). Stats and reputation breakdown; the specification and signal contents stay private.
Leaderboard (demo data). Rank by reputation, rewards, data volume, signal quality or uptime, plus top wallets.	My Crawlers. Your fleet, pause / resume, paid term.
Marketplace (demo mode, after token launch). Buy a proven crawler or rent it for 1–30 days.	Governance (demo mode, after token launch). Vote on boosted narratives, reward split and reputation weights.
Terms & risks. What a payment buys, why signals are not advice, what stays private.

_{Works on a phone too.}

Abuse protection. Every request goes through a per-IP rate limit in src/proxy.ts: a token bucket of 10 requests a second with room for a 60-request burst, 429 with Retry-After beyond that; build assets and images are not counted. The client IP is the last X-Forwarded-For value set by the reverse proxy, so it cannot be spoofed from the client. Heavier actions have their own limits on top: scans per IP and per hour, X checks per day, 20 MCP scans an hour per bot, 10 Telegram scans an hour per chat. On the server only ports 80, 443 and SSH are open, SSH takes keys only, and fail2ban bans SSH brute force, repeat offenders for a week, and sustained floods of the site: an IP that keeps hitting the rate limit for about a minute is written to ratelimit.log and banned at the firewall on ports 80 and 443 for an hour, so its requests no longer reach the web server at all. Pages that crawlers fetch for a user (docs targets) go through a guarded fetcher: http(s) on ports 80/443 only, private, loopback, link-local and cloud-metadata addresses are refused at connection time (so DNS rebinding doesn't help), every redirect is re-checked and the body is capped at 1.5 MB. Wallet sign-in messages name the domain and URI (SIWS / EIP-4361 style) with a server-side timestamp, and POST /api/auth/logout revokes every session of a wallet. OAuth shows the exact redirect host on the consent page, never preselects a bot, limits client registration, and binds refresh tokens to their app. A Grok Bot or Jev take can never be LOOK on a DANGER token, whatever the signal text says. The site sends HSTS, nosniff and frame-ancestors 'none' (only the Telegram app at /tg can be framed by Telegram), and the container runs as an unprivileged user with no capabilities. Volumetric DDoS (raw traffic in gigabits) has to be absorbed by a CDN in front of the server; an app can't do that.

Two kinds of wallets. Connect opens a choice: Phantom (Solana, pay in SOL) or MetaMask, Rabby or any EVM wallet (Robinhood Chain, pay in ETH). The EVM wallet signs in with personal_sign; the server recovers the signer from the signature, so a session can't be opened for an address you don't control. When you pay, the site switches the wallet to Robinhood Chain (chain id 4663) and adds the network if it's missing.

What the app asks your wallet to do: sign a message to log in (free, no transaction) and one transaction per spawn or renewal. Your wallet shows you the exact amount and recipient before you approve. CrawlHive never asks for a seed phrase or private key, and it cannot move funds without your signature.

The home page explains this to visitors in a Wallet safety section (and an Is it safe? hint under the Connect button): connect shares only your public address, sign-in is a plain text message with a one-time code that expires in 5 minutes, a payment is one SOL transfer plus a memo that the server verifies on-chain, and there are no token approvals or delegation. Each point links to the code that does it (auth.ts, solana.ts) or to the treasury on Solscan.

Where spawn payments go. Until the project token exists, spawns are paid in SOL to the public project treasury:

DgCogtUuki6MZzypK1dKHYWfHLMUnKkNUBQwo6rWTGUJ

ETH paid on Robinhood Chain goes to the project's EVM treasury:

0x2FAea62a86Ef02A9B7e61c644FDD8E5358FD0c42

Anyone can audit both balances and their history on Solscan and the Robinhood Chain explorer. The home page shows them live as one buyback fund (SOL + ETH, total in USD, with the part that came from crawler payments), and a badge in the hero links to it. The fund will be spent on buying back the project token once it launches.

How a payment is verified (src/lib/server/solana.ts):

sequenceDiagram
    participant U as You (Phantom)
    participant A as CrawlHive app
    participant S as CrawlHive server
    participant R as Solana RPC
    A->>S: POST /api/spawn/intent (crawler config)
    S->>S: validate config, check SOL balance
    S-->>A: unsigned tx: transfer + memo "crawlhive:spawn:ID"
    A->>U: signAndSendTransaction
    U->>R: signed tx
    A->>S: POST /api/spawn/confirm (intent, signature)
    S->>R: getParsedTransaction
    S->>S: success? signed by you? memo = this intent?<br/>amount ≥ price? recipient = treasury? not reused?
    S-->>A: crawler created

• The memo binds a payment to one specific spawn or renewal (crawlhive:spawn:ID, crawlhive:renew:ID), so a transaction can't be replayed for a second crawler or a second term.
• An intent is locked while its payment is being checked, so two parallel confirmations can't both succeed.
• The crawler config comes from the server-side intent, not from the confirm request, so it can't be swapped after paying.
• Classic SPL Token and Token-2022 are both supported for the future token-burn phase.

ETH payments on Robinhood Chain (src/lib/server/robinhood.ts) follow the same scheme. The intent returns the fields of one plain ETH transfer: to the treasury, the tier price as value, and crawlhive:spawn:ID (or crawlhive:renew:ID) as the transaction data. After the wallet sends it, the server waits for the receipt and checks: status success, sender = your signed-in address, recipient = treasury, value ≥ price, data = this intent, chain id 4663, hash never used before. No approvals, no contracts, nothing but a transfer.

The code is open. Everything that touches your wallet is in this repository; read it before you sign.

Swarm map. Force-directed live map of every crawler and wallet. Filter by narrative (AI, Dogs, Cats, PolitiFi, Gaming, RWA, DePIN, Celeb), source, chain and minimum reputation. Network stats and the epoch timer on top, live signal feed on the side.

Spawner. Four tiers with different limits:

X crawls go through paid Grok search, so they have their own, slower floor per tier.

Paid term. Every spawn or renewal buys 30 days (CRAWLER_TERM_DAYS). The crawler page shows the end date and a Renew button; renewing early adds to the remaining time.

Telegram bot. Long-polling bot (no webhook or open port): wallet linking by one-time code, signal DMs, the Grok Bot's take right after each signal, renewal reminders 3 days ahead.

Running costs, by design. Grok is the only paid dependency, so it is called only when it adds something: free scans never touch it, the X check runs on a button press with one search on a non-reasoning model and is cached for 6 hours, X crawlers have slow per-tier floors, the Grok Bot wakes only on new signals, and MCP calls never trigger a search. A daily call cap (XAI_DAILY_CALLS) backs all of it, and every call logs its token count and price.

Reputation. 0–1000 with grades S/A/B/C/D, recalculated continuously (src/lib/reputation.ts):

Leaderboard. Crawlers by five metrics, plus top wallets by average reputation × fleet size.

Marketplace and governance (demo mode now, live after the token launch). Sell or rent a crawler for 1–30 days, with rewards going to the renter during the lease; credit-weighted proposals on crawl priorities, reward split and network parameters.

Mascot. The logo's octopus-spider crawls over the site with inverse-kinematics legs, runs from the cursor and hides with one click (off automatically for reduced-motion users). Crawlers with a Grok Bot on duty wear its pearl head with the bot's face.

git clone https://github.com/h100envy/crawl-hive.git
cd crawl-hive
npm install
npm run dev            # http://localhost:3000, simulated payments

Node 20+. Without configuration payments are simulated, the demo network is on, and a demo wallet with 250k credits is created if Phantom is not installed. On a server with real payments only Phantom can sign in. Telegram, on-chain and page-change crawlers work without any API key; X crawlers need XAI_API_KEY.

cp .env.example .env      # set PAYMENT_TOKEN, SOLANA_*, XAI_API_KEY
docker compose up -d --build    # serves on 127.0.0.1:8796, state in ./data

Copy .env.example to .env.local:

PAYMENT_TOKEN=sol                              # sol now; "token" after the project token launches
SOLANA_CLUSTER=devnet                          # or mainnet-beta
SOLANA_RPC_URL=https://api.devnet.solana.com
# SOLANA_RPC_RPS=12                            # requests per second to your RPC (shared limiter, retries on 429)
# SPAWN_SOL_RECIPIENT=...                      # defaults to the project treasury
# SPAWN_PRICE_SOL=0.001,0.002,0.003,0.005      # optional per-tier prices (larva..queen)
# SPAWN_ETH_RECIPIENT=0x...                    # turns on ETH payments on Robinhood Chain for EVM wallets
# SPAWN_PRICE_ETH=0.002,0.008,0.03,0.1         # optional per-tier ETH prices
# ROBINHOOD_RPC_URL=https://rpc.mainnet.chain.robinhood.com
XAI_API_KEY=...                                # enables X crawlers and AI reading of Telegram/docs
# XAI_MODEL=grok-4.20-0309-non-reasoning      # model for X search, signal reading and the Grok Bot
# XAI_DAILY_CALLS=60                           # Grok cost limit per day
# SCAN_X_DAILY=20                              # X checks in free scans per day (also 2/hour per IP, cached 6 h)
# OPENROUTER_API_KEY=sk-or-...                 # optional: Jev triage of finds and Grok Bot takes (typesafe/jev-1.13)
# JEV_DROP=0.15  JEV_SURE=0.7  JEV_DAILY_CALLS=3000   # skip-as-noise threshold, sure-enough-to-skip-Grok, daily cap
# DEMO_NETWORK=0                               # production: real crawlers only
# CRAWLER_TERM_DAYS=30                         # days per spawn / renewal
# TELEGRAM_BOT_TOKEN=...  PUBLIC_URL=https://crawlhive.xyz   # signal delivery
# TELEGRAM_ADMIN_IDS=123456  TELEGRAM_ADMIN_USERNAMES=name  # who can open /admin
# JEV_PUBLIC_DAILY=600                         # Jev budget for anonymous Telegram scans
# TOKEN_MINT=...  TOKEN_SYMBOL=CRAWLHIVE         # project token: home block, buyback & burn, reward holder check
# REWARD_MIN_HOLD=1  CREATOR_WALLET=...          # Crawler of the day settings
# SESSION_SECRET=...                           # optional, otherwise generated and stored in .data/
# X402_PAY_TO=...                              # Solana address that receives USDC for x402 calls; unset = x402 off
# X402_PRICE_SCAN=0.01  X402_PRICE_SCAN_X=0.05 # USD per call: scan, scan + X check
# X402_FACILITATOR=https://facilitator.payai.network
# X402_NETWORK=solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp   # or solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1 (devnet)

Default tier prices in SOL: 0.05 / 0.2 / 0.75 / 2.5. In ETH on Robinhood Chain: 0.002 / 0.008 / 0.03 / 0.1.

Devnet helper. node scripts/devnet-setup.mjs sol writes .env.local and creates a faucet wallet in .devnet/ (gitignored). If the public airdrop is dry, top it up at faucet.solana.com; the Spawn page then shows a Get test SOL button. Switch Phantom to devnet in Settings → Developer settings.

End-to-end check without a browser: node scripts/e2e-spawn.mjs <keypair.json> http://localhost:3000 (a local keypair plays the role of Phantom and also checks that a replayed transaction is rejected).

src/
  app/
    page.tsx                 swarm dashboard
    spawn/ my/ signals/ market/ leaderboard/ governance/ terms/ crawler/[id]/
    api/
      swarm/                 graph + stats + recent signals
      crawlers/ [id]/        list, detail, pause/resume, edit targets and specification
      crawlers/[id]/renew/   renewal payment intent + confirm
      signals/               private inbox
      telegram/              link / status / unlink
      scan/ scan/recent/     Instant Crawl (SSE log + verdict), recently scanned
      scan/x/                Check X on demand (Grok), cached 6 h
      bots/ bots/[id]/       your MCP bot keys: create, scope to crawlers, revoke
      bots/duty/             Grok Bot on duty switch per crawler
      treasury/              collected SOL and treasury balance
      auth/                  nonce + signed-message sign-in
      spawn/intent/          build the unsigned payment tx
      spawn/confirm/         verify the tx on-chain, create the crawler
      market/ [id]/          list, buy / rent, delist
      leaderboard/ governance/ wallet/ config/ faucet/
      stream/                Server-Sent Events: signals, spawns, trades
    mcp/                     MCP server for Grok Bot, Claude, Cursor (whats_new, scan_token, …)
  components/                swarm map (react-force-graph-2d), UI kit, wallet provider
  lib/
    economy.ts reputation.ts types.ts
    server/store.ts          network state, paid terms, live crawler bookkeeping
    server/solana.ts         payment intents (spawn / renew), on-chain verification, devnet faucet
    server/robinhood.ts      Robinhood Chain: ETH payment intents and verification, EVM sign-in, ETH treasury
    server/scan-evm.ts       Instant Crawl on Robinhood Chain: contract owner, holders, honeypot
    server/telegram.ts       bot: wallet linking, signal DMs, renewal reminders
    server/scan.ts           Instant Crawl: parallel checks and the 0–100 score
    server/scan-x.ts         Check X: Grok search, who's talking map, cost limits
    server/bots.ts           MCP bot keys (hashed), scopes, whats_new cursor
    server/grok-duty.ts      Grok Bot on duty: wakes on new signals, LOOK / WATCH / AVOID
    server/rpc-limit.ts      shared Solana RPC rate limiter
    templates.ts             ready-made crawlers
    server/crawl/            scheduler and sources: X (Grok), Telegram, on-chain, docs;
                             analyze.ts runs the safety scan, dedupe and price snapshot for every signal
db/schema.sql                target Postgres schema

Stack: Next.js 16 (App Router, Cache Components) · React 19 · Tailwind 4 · @solana/web3.js + @solana/spl-token · react-force-graph-2d · lucide-react.

• Swarm map, reputation, marketplace, leaderboard, governance
• Real on-chain spawn payments through Phantom, server-side verification
• Real crawlers (X via Grok, Telegram, DexScreener, page changes) with per-crawler specifications
• Private signal inbox, outcome scoring against real prices
• Sign-in with a wallet signature
• Signal delivery to Telegram, renewal reminders
• Paid 30-day terms with on-chain renewal
• Production mode: real crawlers only, own domain (crawlhive.xyz), terms & risks
• Instant Crawl: free token scan without a wallet
• Ready-made crawlers, buyback treasury counter
• Instant Crawl: X mentions through Grok, bundle detection (wallets run by one person)
• Instant Crawl: "who's talking on X" map of the authors posting about a token
• Instant Crawl: creator history (earlier pump.fun launches and how many graduated), core assets recognised
• Wallet safety explainer on the home page
• Robinhood Chain: token scans, crawlers on the chain, ETH payments from MetaMask / Rabby into the same buyback fund
• Shareable scan pages (/scan/<address>) with a generated preview card for X and Telegram
• Grok Bots: MCP server for Grok Bot, Claude, Cursor; a bot can watch one, several or all of your crawlers
• Grok Bot on duty: one switch under a crawler, wakes only on new signals
• Safety scan of every crawler signal, peak-based hit scoring, backoff for failing sources
• Running costs cut: X check on demand, non-reasoning model, shared caches
• Contract X-Ray: owner powers from EVM bytecode, risky Token-2022 extensions, drainer code on project sites
• $CRAWLHIVE launch, buyback & burn from the treasury, Crawler of the day; first burn on Oct 15 (1.55M burned)
• Pay per call with x402 (USDC on Solana), Phantom checkout on /agents
• Onchain proof: Merkle root of every verdict and call written to Solana every 15 minutes
• A2A agent, official MCP Registry listing, OpenAPI and llms.txt
• First paid crawlers on mainnet and their public track record
• Postgres persistence (db/schema.sql)
• Project token launch: spawns switch to a token burn (PAYMENT_TOKEN=token), treasury SOL funds buybacks
• Governance results applied automatically (narrative boosts, reputation weights)

• On the production build the home page occasionally logs a recoverable React hydration warning (#418) in the console. It has no visible effect: React re-renders that part on the client. Being tracked.

MIT © 2026 h100envy

_{CrawlHive · built in the open}