Docs
How to search the archive, read an address report, and pull the data out as JSON, CSV, feeds, TAXII or MCP.
Overview
HoneyLabs runs honeypot sensors on the public internet and records every connection that reaches them: the request, the payload, and the TLS, HTTP and SSH fingerprints of the client. No legitimate user has a reason to reach a sensor, so every record is a scanner, a crawler or an attack. Browsing the archive is free and needs no account.
There's a per-IP report at /lookup/<ip>, a JSON variant of the same page, a small HTTP API, and an MCP server so Claude or Cursor can call us directly. A free account covers most analyst use. Paid plans raise the daily credits and how far back a query reaches.
Quick start
Type a query in the search bar. No account needed.
The fastest way in is the search bar at the top of the lookup page and of every other page. Type a query and press enter. Each example below runs live:
For a single address, type the IP, an ASN (AS14061), a CIDR, or a domain and the bar jumps straight to the report. The homepage's recently active scanners list has addresses to try.
The same lookups work over HTTP for scripts, with a free API key from your dashboard: curl -H "Authorization: Bearer <key>" https://honeylabs.net/lookup/<ip>?format=json. Full automation in JSON and MCP.
Address report
Everything recorded about one address on one page.
Open /lookup/<ip> for any public IPv4 or IPv6 address. The report shows:
- Event counts: total, last 24h, last 7d, days active.
- A 90-day activity timeline.
- Top ports hit, with a 14-day sparkline per port.
- TLS / HTTP / SSH fingerprints and how often each was seen.
- HTTP paths and user-agents the IP used.
- Matched CVE signatures (we run payloads through public exploit patterns).
- Related actors and recent raw events.
- UDP activity, such as DNS questions and QUIC client fingerprints, in a separate panel. UDP source addresses can be forged, so it never affects the assessment, the feeds or the leaderboards.
The page also has a curl card with a ready-to-paste request for the JSON form.
Filters
Field filters for the search bar and for URL parameters.
Type any of these into the search bar to get a filtered view across every attacker in the dataset rather than a single IP. Write several and they AND together. Every example in the table is live. Click to run it.
| Type this | Matches |
|---|---|
| port:445 | Destination port the attacker hit on the honeypot. |
| proto:bittorrent | Application protocol nDPI reads from the payload bytes, so a service is labelled correctly even when it runs off its usual port. Values include ssh, rdp, tls, http, bittorrent, mssql-tds, mining, rtsp, smbv1 and more. Also spelled protocol: or service:. |
| asn:14061 | Autonomous System number. AS14061 = DigitalOcean, for example. |
| country:NL | Two-letter ISO country code. |
| cidr:185.177.72.0/24 | IPv4 block. Track a whole scanner farm at once. |
| domain:censys | Substring of the source IP's reverse-DNS, so a partial like 'censys' works. |
| ua:ZGrab | Substring of the HTTP User-Agent. |
| header:x-forwarded-for | Substring of the captured request headers (names and values). Honeypot identity is masked. |
| banner:SSH-2.0-Go | Substring of the event summary: protocol greeting banners (SSH-2.0-..., FTP 220 ...) and raw probe strings a scanner sends, such as the MGLNDD_ marker. Also spelled payload: or greeting:. |
| path:/.env | Substring of the HTTP URL path. |
| method:POST | HTTP request method (GET, POST, PUT, PATCH, DELETE). Exploit attempts and posted credentials are POST/PUT-heavy, so pair it with path: to isolate them from GET scans. |
| body:"/bin/sh" | Substring of the (masked) HTTP request body, where exploit payloads, command injection, and posted credentials live. Quote values that contain spaces or slashes. |
| sni:vpn | Substring of the TLS SNI, the server name the client requested. Shows what a scanner was probing for on a TLS port. |
| cve:CVE-2024-4577 | Events whose payload matched the public exploit pattern for this CVE. |
| ja4:t13d1516h2_... | TLS client fingerprint. Exact match. Copy it from a report. |
| hassh:06046baf... | SSH client fingerprint. Exact match. |
| ja3:e7d705a3... | Legacy TLS client fingerprint (MD5). Exact match, handy for matching TI feeds still keyed on JA3. |
| cert:CN=... | Substring of an mTLS client-certificate subject. Rare; only when a client presents a certificate. |
| has:cert | Match rows where a field is present (non-empty): has:cert, has:ja3, has:ja4, has:hassh, has:sni, has:clienthello (the raw TLS ClientHello). |
| tag:censys | Named scanners (censys, shodan, binaryedge, onyphe, shadowserver, criminalip, ...), the catch-all 'scanner', or a network category: tor, hosting, cdn, isp, enterprise, research_net. |
| port:22 since:24h | Time window, combined with any filter. Defaults to 7d. Solo reaches 30d, Pro 90d, and Team and Research the full archive. |
Stack them. SSH probes from AS24940 in the last 24 hours are asn:24940 port:22 since:24h. On a results page the search bar pre-fills with the active query, so you can edit and re-run without retyping.
Every filter is also a URL query parameter for scripts, such as ?port=445, ?asn=14061&since=24h, so any query you build in the bar is a shareable, scriptable link. See JSON.
Search syntax
How the bar reads key:value terms.
The bar at the top of every page speaks key:value. Several terms AND together. This box runs the same classifier as the search bar, so you can see how a query resolves as you type, then press Run:
Most fields have aliases; they all resolve to the canonical name (and the resolved link above updates to match):
Boolean queries
OR, AND, NOT and grouping with parentheses.
The bar also takes a Lucene/KQL-style query with full boolean logic, the same fields as above. OR and NOT (or a leading -) combine and exclude terms, and AND is the default between adjacent terms. Parentheses group; double quotes wrap values with spaces. Build one below and watch it compile to a ?q= link (aliases get rewritten to canonical on the way):
The request fields can be searched too: method:POST AND path:/boaform isolates exploit attempts from GET scans, and body:"/bin/sh" searches the request body for command-injection payloads.
A query that cannot run returns a chip naming the problem: an unknown field, a malformed value or a port out of range. Values are bound parameters; the query language doesn't open a path to raw SQL. For automation, send the same query as a ?q= URL parameter, URL-encoded, as in the link the box shows.
UDP traffic
DNS questions, QUIC fingerprints and other datagrams.
Sensors also record UDP datagrams. /udp shows the last 24 hours, 7 days or 30 days of them: protocols, destination ports, DNS questions and record types, QUIC client fingerprints, networks, countries and the latest datagrams. A UDP source address can be forged, so UDP traffic is kept out of verdicts, feeds, watchlists and alerts, and every UDP view says so.
The same query language works there, with four fields of its own:
- qname: takes a substring of the DNS question name, for example qname:version.bind.
- qtype: takes a DNS record type, for example qtype:ANY.
- quic: takes the 12-character QUIC transport parameter hash, also served at
/quic/<hash>. - quicver: takes the QUIC version, one of 1, 2 or draft-29.
proto: matches the decoded protocol (dns, quic) or the label the enrichment pipeline gives the datagram (sip, ntp, ssdp, snmp), and proto:raw matches neither. ip:, port:, asn:, country:, ja4:, sni:, tag: and payload:work as on TCP. A JA4 starting with q comes from a QUIC Initial packet and opens a QUIC page at /ja4/q.... Typing a UDP field into the search bar goes to /udp, and so does transport:udp, for example transport:udp port:11211. TCP and UDP are transports, so proto: takes the application protocol and proto:udp is refused with a pointer to transport:udp.
curl -H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx" \
"https://honeylabs.net/udp?format=json&window=7d"
curl -H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx" \
"https://honeylabs.net/udp?q=qtype:ANY&format=json"
curl https://honeylabs.net/api/udp/port/5060Leaderboards
Ranked CVEs, networks, ports and user agents.
Four public leaderboards aggregate across the whole dataset. All refresh continuously and have indexed pages per entity for sharing.
- /cves: every CVE probed in the window (24 hours to 90 days), with CISA KEV flag, events and distinct source IPs per CVE. The counts cover first contact and the requests the interactive sensors answered that targeted that CVE alone or carried its exploit; an address both saw counts once, and each row carries the split. Each row links to
/cves/<CVE-ID>, a per-CVE drill-down with the probes per day, the top source IPs, networks and countries, what the interactive sensors recorded (requests, the payload as sent, what the sources did next) and the URL patterns we match. - /asn/<asn>: per-ASN honeypot activity report (7-day window). Stats cards, top dest ports, top source countries, top user-agents, and the top 25 source IPs in that ASN each linking to their own lookup.
- /port and /port/<n>: most-probed destination ports (top 100) plus a per-port drill-down with top source ASNs, countries, IPs, and user-agents hitting that port.
- /ua: most common User-Agent strings (top 100) by event volume. Each row links to a filtered lookup view of every IP sending that UA.
JSON + CSV variants for every leaderboard:
curl https://honeylabs.net/api/cves?window=7d
curl https://honeylabs.net/api/cves?window=7d&format=csv
curl https://honeylabs.net/api/cves/CVE-2024-4577
curl https://honeylabs.net/api/asn/14061
curl https://honeylabs.net/api/ports?limit=50
curl https://honeylabs.net/api/port/22
curl https://honeylabs.net/api/user-agents?limit=50CVE windows accept 1h, 24h, 7d, 30d and 90d. Team and Research accounts can also ask for 180d, 365d or all, the whole archive, and the daily timeline on a CVE then spans that window.
CSV exports are supported on every leaderboard and on per-IP / per-CVE detail pages via ?format=csv.
JSON
Every lookup URL answers in JSON.
Any lookup URL takes ?format=json with an API key, which you make for free in your dashboard. If you call with Accept: application/json or with curl's default User-Agent, you get JSON without the flag.
curl -H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx" \
https://honeylabs.net/lookup/<ip>?format=jsonTrimmed example response. Sample IP is from RFC 5737 (documentation use); a real request returns the IP you asked about.
{
"ip": "203.0.113.5",
"country": "NL",
"asn": 202425,
"rdns": "scanner.example",
"totals": { "events": 481223, "events_24h": 1842, "days_active": 87 },
"ports": [{ "port": 22, "count": 124091 }, { "port": 445, "count": 88210 }],
"fingerprints": {
"tls": [{ "ja4": "t13d1516h2_8daaf6152771_b1ff8ab2d16f", "count": 12 }],
"ssh": [{ "hassh": "06046bafe5a3...", "count": 8 }]
},
"cves": [{ "id": "CVE-2024-4577", "count": 12 }],
"recent_events": [{ "timestamp": "...", "dest_port": 445, "...": "..." }]
}Without a key, address reports are capped at 30 an hour and 12 a minute per source IP. Other records are capped at 60 distinct ports, CVEs, ASNs or networks an hour and 150 a day, and re-reading one you have already opened costs nothing. Verified search crawlers are exempt. An API key on the request replaces these per-IP limits with your plan's daily credit budget; see the next section.
CSV export
Spreadsheet output for reports and leaderboards.
Most endpoints take ?format=csv for a downloadable spreadsheet. The JSON path is the canonical form; CSV is a convenience for one-off analysis.
# CSV (any leaderboard, the per-IP report, the per-CVE actor list)
curl 'https://honeylabs.net/lookup/<ip>?format=csv'
curl 'https://honeylabs.net/api/cves/<id>?format=csv'
curl 'https://honeylabs.net/api/ports?format=csv'API keys
Your plan's daily credits on every request.
Get a key from your dashboard, then pass it as a bearer token. The key gives you your plan's daily credit budget and time-range window for any HTTP or MCP request. One credit = one row of data returned (minimum one per call), so a top_attackers call with limit=20 costs 20 credits, and a single ioc_lookup costs 1.
curl 'https://honeylabs.net/lookup?asn=14061&since=30d&format=json' \
-H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx"Public showcase data (top countries, top ports, top ASNs) lives at /api/showcase and /api/stats. Neither needs a key.
curl https://honeylabs.net/api/showcaseBulk enrichment
Verdicts for a list of addresses in one request.
Post a block of text and get a verdict for every public address in it. The text can be a list, a CSV column or a raw firewall log: addresses are found anywhere in it, duplicates are dropped, and private, loopback and reserved addresses are counted and skipped instead of billed. Each address costs one credit, and bulk runs may use up to half of your plan's daily credits. The most addresses per request is enrich_addresses_per_request in /pricing.json; without a key the limit is 10.
# 1. Count the addresses and the cost before spending anything
curl -X POST https://honeylabs.net/api/enrich/preview \
-H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx" \
-H "Content-Type: application/json" \
-d '{"text": "80.82.77.202 8.8.8.8 10.0.0.5"}'
# {"ip_count": 2, "non_routable": 1, "cost_credits": 2, "allowed": true, ...}
# 2. Submit. The answer is a server-sent event stream with a row for each address
curl -N -X POST https://honeylabs.net/api/enrich \
-H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx" \
-H "Content-Type: application/json" \
-d '{"text": "80.82.77.202 8.8.8.8"}'Every row carries ip, verdict and verdict_label, total_events, first and last seen, country, ASN, reverse DNS, the ports it hit, its exploit hits and the CVEs it probed. The last event has "_summary": true, a job_id and the credits you have left today. With an account the result set stays available for 24 hours:
curl -H "Authorization: Bearer hlk_..." \
'https://honeylabs.net/api/enrich/<job_id>/results?format=csv' # or json, stix
curl -H "Authorization: Bearer hlk_..." \
'https://honeylabs.net/api/enrich/<job_id>/report?template=executive' # standard, executive, technicalThe report is Markdown, ready for an incident ticket. The Splunk app uses this endpoint for its honeylabs search command.
Watchlists and feeds
Saved queries as email digests and blocklist URLs.
Save any ?q= query under a name. A saved query can send an email digest (daily, or hourly on Pro) and can have feed URLs that a firewall, a Pi-hole or a SIEM cron job pulls. A feed URL needs no login, only its token, which you can revoke, and it is cached at the edge for 5 minutes.
Create from the Watchlists section of your dashboard, or use the Save as watchlist chip on any /lookup?q= results page.
# Feed URL formats. Content-type follows the extension.
curl 'https://honeylabs.net/feed/<token>' # text/plain, a list of IPs (firewall-ready)
curl 'https://honeylabs.net/feed/<token>.csv' # ip,first_seen,last_seen,events,asn,country
curl 'https://honeylabs.net/feed/<token>.json' # the same columns as the CSV, as a list of objects
# Wire into fail2ban / Pi-hole / Cisco / any blocklist consumer:
*/5 * * * * curl -fsS 'https://honeylabs.net/feed/<token>' > /etc/blocklist.txtTokens are 32 random bytes, URL-safe. Anyone holding the token can fetch the feed, which is what lets a firewall pull it without a login. Revoke a token from the dashboard the moment it leaks. The URL stops working within ~5 minutes, on the next edge-cache eviction.
The curated public feeds need no token and no account: exploiters, malware infrastructure, malware samples, second-stage URLs, fingerprints and credentials, each as .txt, .csv or .json. MISP reads the exploiter and malware infrastructure feeds natively. The feeds page lists what each one holds and how it is filtered.
curl https://honeylabs.net/feed/exploiters.txt
# MISP: Sync Actions > Feeds > Add feed, source format "MISP Feed"
# URL https://honeylabs.net/feed/exploiters/mispTAXII
STIX indicators for SIEMs and threat intel platforms.
The curated feeds are also served as STIX 2.1 indicators over TAXII 2.1, the transport SIEMs and threat intel platforms poll natively: Microsoft Sentinel's built-in connector, OpenCTI, EclecticIQ, ThreatQ. Two collections exist: exploiter IPs (7-day window) and malware loader/C2 URLs (14-day window). Indicators carry valid_until, so anything that goes quiet expires out of your platform on its own.
# Discovery (open)
curl 'https://honeylabs.net/taxii2/'
# Collections: exploiters and malware-infrastructure
# 253ff00b-4863-571f-8949-9d05616de5b7 exploiters
# e144c129-a19a-55c8-b926-dd2dfbbd8138 malware-infrastructure
# Objects need an API key as the HTTP Basic password (username is ignored)
curl -u 'taxii:<your API key>' \
'https://honeylabs.net/taxii2/api/collections/exploiters/objects/?limit=100'
# Incremental polling via added_after
curl -u 'taxii:<your API key>' \
'https://honeylabs.net/taxii2/api/collections/exploiters/objects/?added_after=2026-07-15T00:00:00Z'Any HoneyLabs API key works, including free ones, and TAXII polling is not metered against the key's credit quota. Setup walkthroughs: Microsoft Sentinel, OpenCTI.
MCP
HoneyLabs as tools for Claude, Cursor and other agents.
Claude, Cursor, and any other Model Context Protocol client can call HoneyLabs directly. For sample SOC-style prompts and a tool catalog, see /mcp.
The fastest path is the connector. In Claude.ai or Claude Desktop, open Settings > Connectors > Add custom connector, paste this URL, and sign in when prompted. No API key involved.
https://mcp.honeylabs.net/mcpFor Claude Code and other CLI clients, use a key from your dashboard:
claude mcp add honeylabs \
--transport http \
https://mcp.honeylabs.net/mcp \
--header "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx"Then ask Claude something like "what does this IP do on our honeypots?" with an IP from your alerts or logs, and it will call ioc_lookup on its own. Available tools:
| Tool | What it does |
|---|---|
| ioc_lookup | Start here. An IP or domain with our verdict, whether it is a recognised benign scanner, and the CVEs it probed. |
| cve_lookup | Who is probing a named CVE: severity, KEV status, top actors, fingerprints, daily timeline. |
| top_attackers | Leaderboard of source IPs, ASNs, countries, ports, user-agents, or CVEs (by='cve'). |
| search_events | Raw events with every field. Use when you want fingerprints in the response. |
| payload_search | Substring search across request paths, bodies and headers. Never a CVE id. |
| attack_timeline | Hourly or daily attack volume over a window. |
| asn_enrich | Full profile for an ASN: top sources, ports, paths, fingerprints. |
| fingerprint_search | Find activity by TLS, HTTP, or SSH fingerprint. |
| fingerprint_population | The population behind one fingerprint: how many IPs carry it and where they sit. |
| fingerprint_similar | Akin request shapes within a few headers of one fingerprint, and the family it belongs to. |
| udp_activity | UDP datagrams: DNS questions, QUIC client fingerprints and other probes. Source addresses unverified. |
| interactive_credentials | Logins tried against the interactive sensors: the pairs tried most per service, and whether the password was ever sent. |
| interactive_files | Files clients handed to the interactive sensors, by SHA-256, with the VirusTotal verdict when there is one. |
| interactive_sessions | Sessions one address or range held with the interactive sensors: verdicts, services posed as, ports and what the client did. |
The MCP endpoint also supports JSON-RPC 2.0 over HTTP if you'd rather call it from your own code:
curl -X POST https://mcp.honeylabs.net/mcp \
-H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx" \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'For programs
Documents an agent or a program can read instead of these pages.
| Document | Contents |
|---|---|
| /llms.txt | What HoneyLabs is and which interface to use, written for language models. The field and query reference is /llms-full.txt. |
| /openapi.json | OpenAPI 3.1 description of the REST API. |
| mcp.honeylabs.net/mcp/server-card | MCP server card: the endpoint, transport, protocol versions and how to authenticate. |
| /.well-known/api-catalog | RFC 9727 catalog linking the API description, the docs and the MCP server card. |
| /.well-known/ai-catalog.json | AI catalog entry for the MCP server, the API, llms.txt and the plans. |
| /pricing.json | Every plan with its price in EUR excluding VAT and the limits it enforces, built from the same source as the quota checks. |
Plans and limits
Daily credits and query reach for each plan.
| Plan | Daily credits | Requests per minute | Query window |
|---|---|---|---|
| Free | 500 | 10 | 7 days |
| Solo | 5,000 | 30 | 30 days |
| Pro | 50,000 | 60 | 90 days |
| Team | 500,000 | 300 | Full history |
Anonymous limits depend on what you are doing, because reading the site and scripting against it are different activities. In a browser, address reports at /lookup/<ip> are limited to 30 an hour and 12 a minute per source IP. The other report pages allow 60 distinct records an hour and 150 a day, inside an overall budget of 300 requests a day, and revisiting a record you already opened is free. Calling the API directly with no key: 10 requests per day per source IP, on a 7-day query window.
Every response tells you where you stand in X-HoneyLabs-* headers, and every refusal names the cheaper endpoint for what you asked. A free key removes essentially all of this: 500 credits a day, no per-IP ceiling.
Prices and the full comparison are on the pricing page, where every paid plan can be bought directly, and as JSON at /pricing.json.
Privacy
What we store about your account.
We store your email and the API keys you mint. We log query metadata (which tool, how many rows, latency) so we can enforce the quota. We never log the raw output of your queries.
You can export everything we have on your account, or delete the account entirely, from the dashboard. See /privacy for the long version.