Docs

How to search the archive, read an address report, and pull the data out as JSON, CSV, feeds, TAXII or MCP.

On this page

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 thisMatches
port:445Destination port the attacker hit on the honeypot.
proto:bittorrentApplication 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:14061Autonomous System number. AS14061 = DigitalOcean, for example.
country:NLTwo-letter ISO country code.
cidr:185.177.72.0/24IPv4 block. Track a whole scanner farm at once.
domain:censysSubstring of the source IP's reverse-DNS, so a partial like 'censys' works.
ua:ZGrabSubstring of the HTTP User-Agent.
header:x-forwarded-forSubstring of the captured request headers (names and values). Honeypot identity is masked.
banner:SSH-2.0-GoSubstring 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:/.envSubstring of the HTTP URL path.
method:POSTHTTP 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:vpnSubstring of the TLS SNI, the server name the client requested. Shows what a scanner was probing for on a TLS port.
cve:CVE-2024-4577Events 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:certMatch 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:censysNamed 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:24hTime 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.

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:

A filtered query runs as/lookup?country=NL&port=445

Most fields have aliases; they all resolve to the canonical name (and the resolved link above updates to match):

cc = countrycountry_code = countryas = asndest_port = portnet = cidrrange = cidrrdns = domainhost = domainptr = domaintls = ja4ssh = hasshurl = pathuseragent = uauser_agent = uaheaders = headerhdr = headercertificate = certverb = methodservername = snidata = bodypayload = bannergreeting = banner

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.

Terminal
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/5060

Leaderboards

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:

Terminal
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=50

CVE 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.

Terminal
curl -H "Authorization: Bearer hlk_xxxxxxxxxxxxxxxx" \
  https://honeylabs.net/lookup/<ip>?format=json

Trimmed example response. Sample IP is from RFC 5737 (documentation use); a real request returns the IP you asked about.

JSON
{
  "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.

Terminal
# 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.

Terminal
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.

Terminal
curl https://honeylabs.net/api/showcase

Bulk 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.

Terminal
# 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:

Terminal
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, technical

The 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.

Terminal
# 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.txt

Tokens 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.

Terminal
curl https://honeylabs.net/feed/exploiters.txt
# MISP: Sync Actions > Feeds > Add feed, source format "MISP Feed"
#   URL https://honeylabs.net/feed/exploiters/misp

TAXII

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.

Terminal
# 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.

URL
https://mcp.honeylabs.net/mcp

For Claude Code and other CLI clients, use a key from your dashboard:

Terminal
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:

ToolWhat it does
ioc_lookupStart here. An IP or domain with our verdict, whether it is a recognised benign scanner, and the CVEs it probed.
cve_lookupWho is probing a named CVE: severity, KEV status, top actors, fingerprints, daily timeline.
top_attackersLeaderboard of source IPs, ASNs, countries, ports, user-agents, or CVEs (by='cve').
search_eventsRaw events with every field. Use when you want fingerprints in the response.
payload_searchSubstring search across request paths, bodies and headers. Never a CVE id.
attack_timelineHourly or daily attack volume over a window.
asn_enrichFull profile for an ASN: top sources, ports, paths, fingerprints.
fingerprint_searchFind activity by TLS, HTTP, or SSH fingerprint.
fingerprint_populationThe population behind one fingerprint: how many IPs carry it and where they sit.
fingerprint_similarAkin request shapes within a few headers of one fingerprint, and the family it belongs to.
udp_activityUDP datagrams: DNS questions, QUIC client fingerprints and other probes. Source addresses unverified.
interactive_credentialsLogins tried against the interactive sensors: the pairs tried most per service, and whether the password was ever sent.
interactive_filesFiles clients handed to the interactive sensors, by SHA-256, with the VirusTotal verdict when there is one.
interactive_sessionsSessions 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:

Terminal
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.

DocumentContents
/llms.txtWhat HoneyLabs is and which interface to use, written for language models. The field and query reference is /llms-full.txt.
/openapi.jsonOpenAPI 3.1 description of the REST API.
mcp.honeylabs.net/mcp/server-cardMCP server card: the endpoint, transport, protocol versions and how to authenticate.
/.well-known/api-catalogRFC 9727 catalog linking the API description, the docs and the MCP server card.
/.well-known/ai-catalog.jsonAI catalog entry for the MCP server, the API, llms.txt and the plans.
/pricing.jsonEvery 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.

PlanDaily creditsRequests per minuteQuery window
Free500107 days
Solo5,0003030 days
Pro50,0006090 days
Team500,000300Full 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.