🔑 API Keys (0)

Pending Team Invitations

📡 Tier 1 — We Run The Mesh, You Just Connect

Quaggy's own BGP mesh (running on our edge nodes) originates a real-time null-route feed straight from the live scoreboard — the instant an IP hits 100 points, it's announced. Peer your existing router or firewall against it and every one of those exiles gets null-routed at your own edge automatically. No Quaggy software to install — this is standard eBGP.

1. Go to My Organization → BGP Peers and click ➕ Add BGP Peer — give it your router's peering IP and your ASN (no ASN of your own? the default private ASN 64512 works fine).
2. Click the new peer's ⚙️ Config button, pick your platform — Cisco IOS/IOS-XE, Juniper JunOS, or FRR (this covers UniFi UDM/USG too, since it runs FRR underneath) — and copy the generated config straight into your device.
3. Watch the Session State column on that same page flip to ESTABLISHED. That's it — you're live.

From here you're just watching the game: prefix counts and session health update in real time on the BGP Peers page as players get taken off the board.

📤 Tier 2 — Send Data: Report What's Attacking You

Point qcollector at your own logs (SSH, mail, web server, honeypot, firewall, ...) to report attacks into Quaggy's scoring engine. Every report you send adds to the target's score — enough of them, from enough different sources, and that IP goes on the watch list and, eventually, dies. Since you're already peered in Tier 1, your own reports can come back around as a null-route on your own router.

1. Grab an API key/token from My Org → Members (or your own user token under Account Settings).
2. Clone and install (Linux, x86_64/arm64/armv7):

git clone https://github.com/quaggy-org/qCollector.git && cd qCollector
sudo ./install.sh --api-key YOUR_API_KEY --api-token YOUR_API_TOKEN

This installs the binary, a systemd unit, and a starter /etc/qcollector/qcollector.yaml with your credentials filled in. Edit it to add a watcher, e.g.:

watchers:
  - name: "ssh_watcher"
    file: "/var/log/auth.log"
    file_type: "static"        # static | rotate | dated
    catalogs:
      - "ssh"                  # reuse a built-in rule catalog

Then systemctl restart qcollector. Prefer Docker? The repo also ships a docker-compose.yaml — see its README.md for that path.

Built-in catalogs (baked into the binary, no extra download): ssh, nginx, apache, postfix, cowrie, fail2ban, asterisk, freeswitch, opensips, systemd_auth, and malware_signatures. Need something they don't cover? Add a custom rules: block alongside a catalog in the same watcher — see qCollector's README.md for the pattern syntax. (Note: the central, admin-managed "Collector Rules" screen is a work in progress and isn't populated yet — for now, custom patterns live in your own qcollector.yaml, not a shared server-side list.)

🛰️ Tier 3 — Self-Hosted BGP: Run The Mesh Node Yourself

Don't have a router that speaks BGP? Run Quaggy's own qbgp + gobgp pair yourself instead of peering existing hardware — it's the exact same two containers our own edge nodes run.

1. Register your node under My Org → My Self-Hosted BGP Nodes (peering IP, local ASN).
2. Click 📄 qbgp.yaml on your new node to download its config — this already has your node name and API endpoint filled in.
3. Fill in the <API_KEY>/<API_TOKEN> placeholders with a credential that has BGP_MANAGE capability.
4. Clone qBGP, drop your downloaded config in, and bring both containers up (needs network_mode: host for gobgp to actually establish eBGP sessions on your real interface):

git clone https://github.com/quaggy-org/qBGP.git && cd qBGP
cp /path/to/your/downloaded/qbgp.yaml qbgp.yaml
cp gobgp.conf.example gobgp.conf     # fill in your real ASN/router-id/neighbors
docker compose up -d

No Docker? ./install.sh installs the qbgp binary + systemd unit directly, but you'll still need GoBGP running separately — see the repo's README.md.

Once running, your node's live status (session state, prefix counts) shows up automatically under My Org — it phones home via a heartbeat, no extra setup needed.