About The Watchtower
Live since 4 October 2026 · 15,278 addresses in feed.json.
The Watchtower is this board, the list it publishes and the sensors behind it.
servbg.com runs its own small network of sensors on the servers it operates. They record the traffic attacking those servers, which is the same traffic that hits servers like yours: credential stuffing, CVE exploitation attempts, brute-force logins, scanner probes. This page explains what we collect, how an address ends up named on the board, what we never publish, and how a block is lifted.
What counts as an attack
We only store a request when it matches a known attack pattern, a request shaped like a known exploit or scanner tool, a login attempt against SSH, a mail server or an admin panel, or a request to a sensitive path that comes back 401/403/404. Ordinary traffic, a normal page view, a search engine crawler, a visitor browsing the site, is never stored by this pipeline at all, not stored and then ignored: it is never written to the database in the first place.
Every stored request is tagged with two things, from a fixed, published vocabulary (vocab-v1.json in the feeds below):
- Surface, what kind of thing was hit: a web app, a CMS, an admin panel, SSH, mail, DNS, a database, FTP, VPN, an IoT/router endpoint, or one of our own honeypots.
- Attack type, what the request was trying to do: reconnaissance, hunting for secrets or config files, exploiting a known CVE, brute-forcing or spraying credentials, credential stuffing, injection, acting as a spam or open-proxy relay, a denial-of-service pattern, a known scanner tool, bot impersonation, an AI crawler ignoring robots rules, or unknown.
How an address gets named
Every address we see traffic from starts recorded: we store the evidence and publish nothing. An address becomes blocked when its behaviour is evidence of an attack. From then on it has a public page, it is in the list below and our servers refuse it. How much it takes depends on what was asked for:
- One request is enough when the request can only be an attack: an exploit attempt, a hunt for password, key or configuration files, a path that only scanners ask for, a visit to one of our decoys. Nobody asks for those by accident.
- Three requests within ten minutes are needed when a normal visitor or a legitimate mail sender could have caused a single one, such as an odd-looking link or a rejected message.
- Passwords have their own rule. Where we can see the username, a sign-in for a name that does not exist blocks at once. One wrong password for a name that does exist is forgiven, because people mistype their own. A second wrong password within ten minutes blocks. Where we cannot see a name (the control panel, our web terminal, a sign-in link, an access token), the second failure blocks. Five wrong passwords within a week block however far apart they are. Someone who signed in to one of our services in the last 30 days is not treated this way, and neither are our own servers.
A score ranks addresses and never decides a block. A block has no end date: it stays until we lift it, and the evidence behind it stays too. An address we lifted that attacks again is blocked on its first new attack and marked Repeat offender. That mark means blocked at least twice, nothing else.
Blocks within minutes
A block does not wait. Once an address has met the rule above, our servers drop it within minutes, and it reaches every server we run and the published list a few minutes later. This applies to every kind of network, home and mobile connections included. Addresses that recently signed in to one of our services, and our own servers, are never blocked this way. How a block is lifted is described at the end of this page.
Reputation
Every address keeps a long-term record next to its current score: how many attack-shaped requests it has sent in total, on how many separate days, against which kinds of service, and how many times it has been blocked. From that record we give each address an all-time reputation score from 0 to 100. Each request counts by its severity and fades by half every 30 days (a half-life of 30 days), so recent behaviour weighs most, and that total is compressed so that sheer volume cannot run away with the ranking. On top of it an address gets up to 20 points for the number of days it was active, 4 points for each kind of service it attacked, and 4 points for each time it was blocked (counted up to five times). An address that was blocked once and comes back is blocked again on its first new attack and is marked Repeat offender: that mark means blocked at least twice, nothing else. The all-time ranking counts every blocked address, whatever its network.
Each network (ASN) also gets a record on its own page: how many of its addresses are blocked now, what share of the addresses we have seen from it that is, the most blocked addresses in any one /24, how long its blocks have been in force (the median), how many days it has gone without an attack on our sensors (its clean streak). A network is marked dirty when at least 5 of its addresses are blocked, or 3 in one /24, or at least 3 and half of the addresses we have seen from it.
What we publish, and what we never do
Published, once an address is blocked: the address itself, its reverse DNS, its network (ASN) and organisation name, its network type (hosting, cloud, residential, mobile, education, or unknown), its country (never a city), Tor/VPN/cloud flags, the request paths and user-agent strings it sent (with anything that could identify a real person already stripped before we ever write the row, see below), timestamps, the attack classes observed, and aggregate honeypot-credential statistics (the top 20 most common passwords submitted across every honeypot hit, shown as a simple counter with no address attached).
Never published, by design:
- Any tenant's or visitor's own data, or any content from a hosted site. This board is about traffic attacking our sensors and honeypots, never about who visits a site or what a site contains.
- Email-like strings, session cookies, or anything else inside a request that looks like it could identify a real person, these are stripped before the row is ever written to the database, not filtered later when a page renders.
- A password in clear tied to the address that sent it. We keep only a salted hash per address; the one place a password shows up in clear is the aggregate top-20 counter above, which names no address.
- Guesses about who or what is behind an address. We publish what an address's traffic did, "this address tried a WordPress credential-stuffing tool against several sites", never a label about who runs it. "Hosts a web server" is a fact we can check; "is probably a compromised home router" or "is likely run by a known group" is a guess about a third party, and we do not publish guesses.
Every network is treated alike
Hosting, cloud, home, mobile, school and unknown networks get the same treatment. The same attack is the same attack whatever the network: most of it comes from botnets built from rented servers and from hacked home computers, phones and devices alike. An address on any network is published in full and ranked like the others, and its page is open to search engines. The type of network is a label on the page and in the feed, and the location is the country only.
Some addresses are shared: a mobile carrier gateway or an office line can hide many people behind one address, and a block there also stops people who did nothing. That is why a block is lifted whenever the holder writes to us and has fixed the cause. How, is at the end of this page.
AI crawlers get a facts-only table, never a score
The board's AI-crawler table (last 30 days) counts requests whose User-Agent claims to be one of the well-known AI-training or search crawlers (GPTBot, ClaudeBot, PerplexityBot, DeepSeekBot, Bytespider, Amazonbot, CCBot and a few others we've actually seen) against three facts, and nothing else:
- Admin/sensitive path vs. ordinary page, did the request land on a path our pipeline already treats as sensitive (
.env,wp-admin, credentials/config filenames, and the rest of our sensitive-path list), or somewhere ordinary? - rDNS confirmed vs. not, does the address's reverse-DNS hostname (our own enrichment, not a live lookup made when you load this page) land in the domain that crawler's own User-Agent string names as its home (e.g. ClaudeBot's own UA names anthropic.com)? "Not confirmed" means exactly that: the one fact didn't check out. It does not mean the traffic is fake, malicious, or anything else, plenty of real infrastructure sits behind addresses whose rDNS was never set to anything informative.
- Blocked at the edge vs. reached the origin, did Cloudflare's own managed AI-crawler rule stop the request before it ever reached the servers we watch, or did it arrive at the origin (regardless of what HTTP status it then got)?
None of the three facts in this table, the path split, the rDNS check, the edge outcome, feed the scoring in "How an address gets named" above; they are computed only for this table. An address whose traffic happened to carry one of these User-Agents is scored by the exact same rules as any other address (volume, how many of our sensors saw it, auth-failure patterns), the attack type "ai-crawler" gets no special weight, bonus or exemption in that scoring. The table exists so you can see what we see; it is not a verdict.
Blocking: what it actually stops
A block is applied by the firewall on each of our servers. Every server blocks IPv4 addresses. IPv6 networks are blocked only by our main web server and at the Cloudflare edge. It stops a direct connection to the server: mail, SSH, FTP, the control panel, and web traffic to any site there that is not behind Cloudflare. Web requests to the sites that are behind Cloudflare reach us from Cloudflare's own addresses, so the firewall cannot see who sent them; for those, our web servers look at the visitor address Cloudflare passes on and answer a blocked IPv4 address with "403 Forbidden", on every site we host. A blocked address can still read this board, its own page, the feeds and /.well-known/security.txt, so it can find out why. Since 12 October 2026 our list is also applied at the Cloudflare edge: a request from an address on it is stopped there, before it reaches us. On our own sites and on others that asked for it the request is refused; on the rest the visitor is asked to pass a challenge instead. The plan allows 10,000 entries, so the edge list holds the 9,500 most recently blocked addresses; older blocks are still refused by our own servers. Cloudflare's own managed rules and challenges do stop some requests before they reach us, whatever our list says, and the live feed shows those as "blocked at edge". IPv6 addresses are blocked as their /64 prefix, which is the unit an attacker rotates inside. Our main web server drops them at its firewall, and the Cloudflare list stops them for every site behind it. Our own management SSH port is exempted from every block, ahead of the drop rule, so a blocked address can still reach it and we can never lock ourselves out by running this system.
Retention
| Data | Kept for |
|---|---|
| Raw attack events | 90 days |
| An address's record (score, state, history) | for an address that was ever blocked, with no end date; for every other address, 365 days after its last activity |
| Every redacted evidence line of an address that was ever blocked | kept for as long as the address's record exists, lifted blocks included, so a return brings the whole record back |
| An address's long-term reputation record (counts and dates only, no request lines) | for an address that was ever blocked, with no end date; for every other address, 365 days after its last activity |
| A message from someone asking us to lift a block | read and answered by a person; we keep no request log, ticket or list |
| Abuse-report records we sent to hosters | 2 years |
| Honeypot usernames tied to a specific event | follow that event's own retention above |
| Honeypot password hashes | follow that event's own retention above; never shown in clear per address |
| The top-20 clear-password counter | kept indefinitely, it names no address and holds no personal data |
Legal basis and your rights
We rely on GDPR Article 6(1)(f), legitimate interest, protecting our own hosts and the sites on them, and giving other small operators a free, signed feed of the same confirmed offenders. We do not profile people; we score addresses and their observed traffic. Because direct notice to an attacking address is not practical, this page serves as the Article 14 notice to anyone whose address appears here. The controller of record is СЕРВБГ ООД; the full legal reasoning and balancing test are available on request from [email protected].
The feeds
We publish the blocked-address list as plain files, kept current within minutes of a block:
feed.txt, one blocked address per line: IPv4 addresses first, then a comment line, then IPv6 as /64 prefixes. We score IPv6 per /64 because attackers rotate inside one; a /128 entry would block one address out of 2^64. This is the same shape CSF's own blocklist mechanism and Cloudflare's IP-list import both already expect, so no separate CSF-specific or Cloudflare-specific file exists. A comment line separates the two groups, so a consumer that reads IPv4 only can stop there.feed.json, the same addresses with score, first and last seen, the classes observed, a link to the dossier and anexpiresfield that is alwaysnull: a block has no end date and ends only when we lift it. It also carries ahistorysection, every address that has ever been blocked with the last time we saw it, including ones we have since lifted. Not a current block list: use it for scoring and alerting, and do not enforce it without an expiry of your own.released.txt, the addresses we stopped blocking in the last 14 days, one per line with the time of the release and the reasonowner(we lifted it ourselves). It is for anyone who loads the block list and wants to lift blocks promptly. A release means we stopped blocking this address. It is not a clearance and says nothing about the address today. An address that we allowlist, or that signs in to one of our services, leaves no line here. Verify it like the block list:released.txt.minisigsits next to it.vocab-v1.json, the surface/attack-type vocabulary used above, so a consumer can decode the classes without reading our code.
Earlier versions of this page offered separate lists by service, by confidence, for home and mobile networks, for IPv6 and for history. Those files now carry their share of the same entries, and a first line in each says when it stops. After that date they are gone: use feed.txt and released.txt.
Every file carries a header comment with its generation time, a stale_after: 7d figure, this page's URL, and the contact address above. Every file is signed with minisign; the public key is published at pubkey.minisig next to the feeds, so you can verify a file before trusting it.
To read the board in a terminal, fetch https://servbg.com/threats/report.txt with curl: it prints the week and the top networks as plain text, and it is a reading aid, not a signed feed.
Terms: the feeds are free, require no account, and carry no warranty. We sign them so you can verify where they came from; we do not promise they are complete, free of false positives, or fit for any particular firewall. If you consume them, you are responsible for your own firewall configuration and for deciding when a feed is too stale to trust (we recommend flushing your local block set if a feed is older than the stale_after value in its header). A small, dependency-free pull script is provided as a convenience for exactly this.
Use the list
Tested snippets, one per firewall. Every one of them pulls feed.txt (the list described above). It lists IPv4 addresses first, then a comment line, then IPv6 networks as /64 lines. CSF loads both; the pfSense and ipset snippets load the IPv4 lines only.
pfSense (pfBlockerNG), IPv4 tab, add a custom list:
- URL:
https://servbg.com/feeds/threats/feed.txt - Update frequency: 1 hour
- Action: Deny Inbound
CSF, add this line to csf.blocklists:
SERVBGWANTED|3600|0|https://servbg.com/feeds/threats/feed.txtName, interval and limit follow CSF's own rules for that file: an uppercase-alphabetic name of 25 characters or fewer, an interval of at least 3600 seconds, and a MAX of 0, which takes every line. A smaller MAX keeps only the first lines, so it drops the end of the IPv4 list and every IPv6 line. The list grows every day, so turn on LF_IPSET in csf.conf and set LF_IPSET_MAXELEM to 1048576.
Plain Linux (ipset + iptables):
set -e
curl -fsS -o /tmp/wt.txt https://servbg.com/feeds/threats/feed.txt
ipset list -n servbg_wanted >/dev/null 2>&1 || ipset create servbg_wanted hash:ip maxelem 1048576
ipset destroy servbg_wanted_new 2>/dev/null || true
ipset create servbg_wanted_new hash:ip maxelem 1048576
grep -E '^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$' /tmp/wt.txt | sed 's/^/add servbg_wanted_new /' | ipset restore -exist
ipset swap servbg_wanted_new servbg_wanted
ipset destroy servbg_wanted_new
iptables -N SERVBG_WANTED 2>/dev/null || true
iptables -F SERVBG_WANTED
iptables -A SERVBG_WANTED -m conntrack --ctstate ESTABLISHED,RELATED -j RETURN
iptables -A SERVBG_WANTED -p tcp --dport 22 -j RETURN
iptables -A SERVBG_WANTED -j DROP
iptables -C INPUT -m set --match-set servbg_wanted src -j SERVBG_WANTED 2>/dev/null \
|| iptables -I INPUT -m set --match-set servbg_wanted src -j SERVBG_WANTEDThe new set is filled first and swapped in, so there is never a moment with an empty set. It holds up to 1,048,576 addresses, about twice what we expect the list to reach in a year. The chain returns established connections and SSH (change 22 to your port) before it drops, so a stale or wrong pull can't lock you out of your own box. Run it from cron every 10 to 30 minutes.
If you would rather not maintain that by hand, the pull client below does the same with the checks built in: signature, freshness, your firewall's own persistence, SSH kept open, one-command removal.
Verify before you trust it, every feed file ships a detached signature next to it (feed.txt.minisig and so on), against the public key at pubkey.minisig:
minisign -Vm feed.txt -p pubkey.minisigThe key's own comment states its id: servbg.com threat-board feed signing key (key id 9d1640d9d818429c). If that command doesn't say the signature and comment both verified, don't load the file.
The rest of the feeds: feed.json is the same addresses with score and an expires field per address (null: a block has no end date); released.txt lists the blocks we lifted; vocab-v1.json decodes the attack-class names used elsewhere on this page. Each text feed carries the same header comment shape, and every file has its own detached .minisig signature next to it.
Free, signed, no warranty, see Terms above.
Pull the block list
A small script does what the manual snippet above does, plus the checks that are easy to skip: it verifies each download against a key you pinned once, refuses an unsigned, mis-signed or stale feed, finds your firewall and uses that firewall's own persistence, keeps your SSH port reachable, and removes everything it added with one command. It runs only when you install its timer. One dependency: minisign (a package on Debian, Ubuntu, Fedora, Alpine, Arch and FreeBSD).
Install (as root):
curl -fsSO https://servbg.com/feeds/threats/client/watchtower-pull.sh
install -m 0755 watchtower-pull.sh /usr/local/sbin/watchtower-pull.sh
mkdir -p /etc/watchtower
watchtower-pull.sh --show-keyPin the key. --show-key fetches the public key file as published. Its first line names the key id: 9d1640d9d818429c. If the id you see is different, stop and write to us before going further. Put the second line into the config as PUBKEY=:
# /etc/watchtower/pull.conf
FEED_URL=https://servbg.com/feeds/threats/feed.txt
PUBKEY=RWSdFkDZ2BhCnFMaPrwsWM2kuzOMB/LPb79AdntSMH5cdVI/ucFTfP2KOptional keys: SSH_PORT= (read from sshd -T by default, every Port value), FIREWALL= (csf, shorewall, firewalld, ufw, nftables or iptables; detected by default), SET_NAME= (default servbg_wanted), MAX_AGE= (a shorter freshness limit than the feed's own, for example 2d). IPv4 lines go into the IPv4 set. IPv6 prefixes are loaded only where your firewall supports them, and a dry run reports how many it skipped.
Dry run first:
watchtower-pull.sh --dry-runIt prints the firewall it found, the SSH ports it keeps open, the signature verdict, the feed's age and every command it would run, then changes nothing. On a host where it cannot identify one of the six supported firewalls it prints what it looked for, applies nothing and exits non-zero. It never guesses.
What it adds, per firewall. In every case the set is filled first and swapped in, so there is never a moment with an empty set, and established connections and your SSH port are returned before the drop rule.
| Firewall | What is added | How it survives a restart |
|---|---|---|
| CSF | an ipset and a chain hooked at the top of INPUT | a marked block in csfpost.sh, which CSF runs after every reload |
| Shorewall | an ipset and two rules (accept SSH, drop the set) | a marked block in the rules file, applied with a reload |
| firewalld | a permanent ipset bound to the drop zone, with an accept rule for SSH ahead of it | firewalld's own permanent config |
| ufw | an ipset and a chain | marked blocks in before.rules and before.init |
| nftables | its own table inet watchtower with the set and an input chain | re-applied by every timer run |
| iptables | an ipset and a chain hooked into INPUT | re-applied by every timer run |
Run it on a timer:
curl -fsSO https://servbg.com/feeds/threats/client/watchtower-pull.service
curl -fsSO https://servbg.com/feeds/threats/client/watchtower-pull.timer
install -m 0644 watchtower-pull.service watchtower-pull.timer /etc/systemd/system/
systemctl daemon-reload
systemctl enable --now watchtower-pull.timerEvery 15 minutes it fetches feed.txt and its signature, verifies, and swaps the new set in. A feed older than its stale_after value (7 days) is not trusted: the local set is flushed and the run reports a failure, so a feed that stopped updating cannot keep blocking anyone. watchtower-pull.sh --status shows the set and the last good feed.
Uninstall, in one command plus the timer:
systemctl disable --now watchtower-pull.timer
watchtower-pull.sh --uninstallfail2ban and this list do not conflict. fail2ban bans addresses it sees failing on your host; this list drops addresses seen attacking elsewhere, before they reach a service. Do not feed this list into fail2ban as a jail and do not export fail2ban's bans into this set: each tool keeps its own count honest.
pfSense and OPNsense need no script. Point the list manager at the plain feed.txt URL (pfBlockerNG settings above; on OPNsense: Firewall, Aliases, type URL Table (IPs), refresh every hour) and use it in a block rule.
Run a sensor
The list is built from attacks our own servers record. A sensor lets a server we do not run report too. The sensor client reads your logs (an Apache or nginx access log, the SSH daemon's journal or auth log), keeps only the attack-shaped lines, strips anything personal or secret on your host, and posts the rest to us in batches with a token that identifies your sensor. It is a POSIX shell script that needs curl, awk and sed, nothing else.
What leaves your host, and what never does. Per event: the time in UTC, the attacking address, which kind of service was hit (from a fixed list), your host label and optionally the site name, the request method and path, the user agent, the HTTP status, and the log line itself, cut to 1 KB and redacted. Redaction runs before anything is sent: query strings are cut at the ?; Authorization and Cookie headers, bearer tokens, password-like parameters and long hex or base64 strings (session ids, tokens, hashes) become <redacted>; email addresses become <email>; usernames in login failures become <user>; credentials embedded in URLs are dropped. Ordinary traffic is not sent at all: a line becomes an event only if its status is 4xx or 5xx, its method is POST, PUT, DELETE, OPTIONS or PROPFIND, or its path matches the bundled attack-path patterns in prefilter.regex. Successful SSH logins are never sent. We redact once more on arrival. What you send is stored under your sensor's public name and shown on dossiers; it counts toward scores only after we have marked your sensor trusted, and on its own it never puts an address on the public list (see "Whose sensors" below).
Getting a token. Tokens are issued by hand. Write to [email protected] with the subject "sensor token", the public name the sensor should carry, and what it watches. A token is wt1_ followed by 40 hex characters. You see it once; we keep only its hash. Store it in /etc/watchtower/token, mode 0600, and treat it like a password. If it leaks, write to us and it is revoked.
Install:
mkdir -p /etc/watchtower
cd /usr/local/sbin
curl -fsSO https://servbg.com/feeds/threats/client/watchtower-sensor.sh
curl -fsSO https://servbg.com/feeds/threats/client/threat-vocab-v1.json
curl -fsSO https://servbg.com/feeds/threats/client/prefilter.regex
chmod 0755 watchtower-sensor.shConfig:
# /etc/watchtower/sensor.conf
URL=https://servbg.com/api/threats-ingest.php?v=1
TOKEN_FILE=/etc/watchtower/token
HOST=www1
SITE=example.org
BUFFER_DIR=/var/lib/watchtower
MAX_BUFFER_MB=50
LOG=combined /var/log/nginx/access.log web web-cms
LOG=sshd journal:sshd ssh sshEach LOG= line is <format> <source> <sensor> <surface> [site]. Format is combined (an Apache or nginx combined log, with or without a leading virtual-host field) or sshd (the journal, read with journalctl -o short-iso, or a syslog-style auth log). <sensor> is one of web, ssh, mail, panel, honeypot, edge. <surface> is one of the values in the bundled threat-vocab-v1.json: web-cms, web-app, web-static, panel, ssh, mail-smtp, mail-imap-pop, mail-webmail, dns, db, ftp, vpn, iot-router, honeypot. A log whose surface is not in that file is refused on your side with a logged reason, before any request exists; the same rule rejects a whole batch on our side, so a wrong value shows up at once rather than being stored as something else.
Dry run:
watchtower-sensor.sh --dry-runprints the redacted events it would send, one JSON object per line, and makes no network connection at all (check it yourself with strace -f -e trace=connect). A dry run writes nothing: no cursor, no buffer.
Heartbeat. Every run also tells us the sensor is alive, even when there is nothing to send: your host label, the client version, how many events are waiting, how many were refused, the time of the newest event, the sensor's own clock, and for each watched log how long ago it last moved. It carries no events and no log lines. We show a sensor as ok while its last heartbeat is under ten minutes old, late up to thirty minutes, and silent after that, and we compare its clock with ours so a drifting clock is noticed. A sensor that has never sent one is listed as having no heartbeat and is not counted as late or silent. A heartbeat may also carry five numbers about the sensor's own host (free disk, journal size, free memory, load and uptime) and nothing else; they are optional, older clients keep working without them, a number out of range is noted in the reply and ignored, and a host whose numbers stay poor on two heartbeats is shown to the owner as degraded. Heartbeat records are deleted after 30 days.
Run it every five minutes with a systemd timer (the vocabulary and prefilter files must sit next to the script, as above):
cd /tmp
curl -fsSO https://servbg.com/feeds/threats/client/watchtower-sensor.service
curl -fsSO https://servbg.com/feeds/threats/client/watchtower-sensor.timer
install -m 0644 watchtower-sensor.service watchtower-sensor.timer /etc/systemd/system/
systemctl daemon-reload
systemctl enable --now watchtower-sensor.timer
systemctl start watchtower-sensor.serviceThe first run sends the first heartbeat at once. A host without systemd can run watchtower-sensor.sh from cron every five minutes instead.
Each run continues from where the last one stopped (rotation-safe, by inode and offset), sends up to 500 events or 240 KB per request, and keeps a bounded buffer on disk when we are unreachable: the oldest events drop first and the drops are counted in --status. It honours Retry-After, backs off with jitter on errors, stops on a refused token, and drops events older than seven days, which we would reject anyway. --pull-feed runs the pull client after sending, if it is installed next to the script.
Contract v1
For anyone writing their own client. This is the whole interface; the shell client above uses nothing more.
Endpoint: POST https://servbg.com/api/threats-ingest.php?v=1 with the header Authorization: Bearer <token> and a JSON object body carrying events, aggregates, a heartbeat, or any combination. Any other top-level key is an error. A body with none of the three, or with only "heartbeat": null, is a 400 "empty batch". At most 500 events plus aggregates per request and 256 KB of body.
An event:
| Field | Required | Meaning |
|---|---|---|
ts | yes | ISO-8601 UTC, 2026-10-12T06:00:00Z; not older than 7 days, not more than 5 minutes in the future |
ip | yes | the attacking address, IPv4 or IPv6 |
sensor | yes | one of edge, web, mail, ssh, panel, honeypot |
surface | yes | one of the surface values in vocab-v1.json |
host | yes | your label for the reporting host |
site | no | the site or domain that was hit |
request | no | method and path, query string removed, for example GET /wp-login.php |
ua | no | the user agent |
status | no | the HTTP status as a number |
raw | no | the log line, redacted by you, at most 1 KB |
An aggregate, for an operator who counts instead of exporting lines:
| Field | Required | Meaning |
|---|---|---|
ts_window_start | yes | ISO-8601 UTC start of the window |
window_minutes | yes | window length |
ip | yes | the attacking address |
surface | yes | as above |
class | yes | one of our attack classes, as named in the classes field of feed.json and on dossiers |
attack_type | no | one of the attack_type values in vocab-v1.json |
count | yes | attempts in the window |
server | yes | your label for the server; never shown publicly |
instance_id | yes | your label for the reporting instance; never shown publicly |
A heartbeat, an object in the same body (optional, and alone is enough):
| Field | Required | Meaning |
|---|---|---|
host | yes | your label for the reporting host, 1 to 64 characters |
client_version | yes | the client's version, an integer from 1 to 999 |
queue_len | yes | events waiting to be sent, an integer from 0 to 10,000,000 |
rejected_total | yes | events refused, cumulative, an integer from 0 to 1,000,000,000 |
last_event_ts | no | ISO-8601 UTC time of the newest event seen, or null |
sent_at | yes | the sensor's own clock, ISO-8601 UTC |
sources | no | up to 32 entries of {"log": "<label, up to 128 characters>", "cursor_age_s": <seconds since that log last moved>} |
A heartbeat uses the same rate budget as any batch. A malformed heartbeat does not discard the events sent with it: they are stored and the reply carries "heartbeat":{"rejected":{"field":"queue_len","reason":"..."}}. A request holding only a malformed heartbeat is a 400. A valid heartbeat is stored even when the events in the same request are refused with a 400, and that reply says "heartbeat":"ok" too.
The reply on success is 200 with:
{"contract_version":1,"vocab_version":1,"deprecated_after":null,
"accepted":14,"duplicates":0,"replaced":0,"rejected":0,"batch_id":123}Events are idempotent on (token, ts, ip, sensor, request): posting the same batch twice reports the second as duplicates and stores nothing new. Aggregates are keyed on (token, instance_id, server, ts_window_start, ip, class): posting a window again replaces its count and is reported as replaced. When a heartbeat was stored the reply gains "heartbeat":"ok"; a heartbeat-only request reports accepted 0 and a null batch_id.
Errors:
| Status | Meaning |
|---|---|
400 | validation failed; the whole batch is rejected and nothing is stored. The body lists up to 20 problems as {"index":i,"field":"surface","reason":"not in vocab v1"} |
401 | unknown or malformed token |
403 | the token is revoked, or intake is paused |
405 | not a POST |
413 | body over 256 KB |
429 | over the limit of 120 batches per hour for this token; wait the Retry-After seconds |
A value outside the vocabulary anywhere in the batch is a 400 for the whole batch, on purpose: a client bug should surface at once. We redact raw, request and ua again on arrival and store the redacted form only. A token is never shown again after it is issued, and is stored only as a hash. The contract is versioned in the URL; a later version will be announced here and the reply's deprecated_after field will carry the date when this one stops.
How a block is lifted
Every listing carries its evidence on its page, and blocks are lifted only by us; if you were blocked and have fixed the cause, write to abuse-reports@abuse.servbg.com.
Whose sensors
The sensors are our own servers, plus sensors run by other operators who asked for a token (see "Run a sensor" above). An address only ever reaches "blocked" on evidence recorded by at least one of ours; evidence from other sensors is shown on dossiers under the sensor's public name and, once we trust that sensor, counts toward scores, but on its own never puts an address on the public list. The list is for everyone: the addresses on it attack servers like yours too.
What this page is not
This page states policy and method for a technical reader. It is not legal advice. If anything here is unclear or looks wrong, write to [email protected] and we will answer in writing.