Hetzner Server Auction Monitor — Instant Alerts for Dedicated Server Deals

Never miss a cheap dedicated server again. This Actor watches the Hetzner Server Auction (the Serverbörse) around the clock, filters every listing against your specs — price, RAM, ECC, disk, datacenter, CPU — and fires an instant webhook the moment a matching bargain appears. Plug it into Slack, Discord, Make, Zapier, n8n, your own API, or a downstream Apify Actor and turn Hetzner's fast-moving auction into a hands-off deal pipeline.

Hetzner's auction inventory changes by the minute and the best-value servers get snapped up in seconds. Refreshing the page yourself doesn't scale. This monitor does the watching for you and pings you only when something you actually want shows up.

Why use this Actor

• ⚡ Real-time bargain alerts — get notified the second a server matching your criteria hits the auction, not hours later.
• 🎯 Precise filtering — match on max monthly price, minimum RAM, ECC memory, disk type (NVMe / SATA / HDD) and capacity, datacenter location, and CPU model.
• 🔔 De-duplicated by design — you're alerted once per server. No repeated pings for listings you've already seen.
• 🔗 Wire it into anything — generic JSON webhook to any HTTP endpoint, or native Apify dataset integrations for no-code automation chains.
• 🤖 Self-scheduling — optionally have the Actor maintain its own recurring poll, so you set it up once and forget it.
• 🛡️ Robust — feed shape is validated every run; flaky webhooks are retried with backoff and never crash the job.

Who it's for

• Self-hosters & homelabbers hunting a cheap, high-RAM box for Proxmox, a NAS, game servers, or media.
• Startups & agencies sourcing low-cost dedicated compute without committing to retail pricing.
• Developers & DevOps teams automating infrastructure procurement.
• Resellers & deal-hunters tracking when specific configs drop below a target price.

What it does

On each run the Actor:

1. Reads your input criteria.
2. (Optional) Ensures its own recurring Schedule exists, so it keeps polling automatically.
3. Fetches the live auction feed and validates its shape.
4. Filters listings (max price, min RAM, ECC, disk type/size, datacenter, CPU).
5. Diffs against the IDs it has already seen (stored in a named key-value store).
6. On the first run, silently records existing matches (seeding) so you aren't flooded.
7. For each fresh match: pushes it to the dataset and POSTs a webhook (if a URL is configured).

Input

Field	Default	Notes
currency	EUR	EUR or USD. Price criteria are interpreted in this currency.
maxPrice	50	Max monthly price.
minRamGB	128	Minimum RAM in GB.
requireEcc	false	Only ECC memory.
diskType	any	any / nvme / sata / hdd.
minDiskGB	–	Minimum total disk capacity (GB).
datacenters	[]	Location prefixes, e.g. ["FSN","NBG","HEL"]. Empty = any.
cpuIncludes	–	Case-insensitive substring of the CPU model.
genericWebhookUrl	–	Secret. POST target for each fresh match.
notifyOnFirstRun	false	Fire webhooks on the first run too (skips seeding).
selfSchedule	false	Create/maintain a recurring Schedule. Needs Full permissions.
cron	*/10 * * * *	Schedule cron (only when selfSchedule is on).
scheduleName	–	Schedule name / idempotency key.

The defaults (≤ €50/mo, ≥ 128 GB RAM) target large-RAM bargains; loosen them to see more matches.

Output

Every fresh match is pushed to the Actor's dataset (one row per server) and is available as JSON, CSV, Excel, or via the API. Fields include the listing id, cpu, ramGB, ecc, disk, price, currency, datacenter, specials, and a direct url to the auction listing.

Webhook payload

{
  "event": "new_hetzner_match",
  "server": { "...full listing from the feed..." },
  "currency": "EUR",
  "summary": "AMD Ryzen 5 3600 · 64 GB RAM · 2x NVMe (1024 GB total) · 38 EUR/mo · FSN1-DC15",
  "url": "https://www.hetzner.com/sb?search=<id>"
}

Delivery is per-item and isolated: timeouts / 5xx are retried with backoff, and a permanently failing webhook is logged and skipped — it never crashes the run.

Wiring to a downstream Actor

Two supported options:

1. Direct webhook — set genericWebhookUrl to a downstream Actor's run endpoint (https://api.apify.com/v2/acts/<actor>/runs?token=…). Each match starts that Actor with the listing as input.
2. Native Apify integration (recommended for publishing) — leave genericWebhookUrl empty. Because only fresh matches are pushed to this Actor's dataset, you can chain a downstream Actor via Apify's built-in integrations on new dataset items / run success.

Self-scheduling & Full permissions

selfSchedule makes the Actor create and maintain its own recurring Schedule (looked up by name, so it never duplicates — running it manually or from the schedule both converge on one schedule). Scheduled runs carry selfSchedule: false as a recursion guard.

Schedules are an account-level resource, so the run needs Full permissions:

• Set the permission level to "Full permissions" in the Actor's Console → Settings (this is not configured in actor.json).
• For your own Actor, no extra approval is needed.
• If you don't own the Actor, you must approve the Full-permission request once in the Console; otherwise API-triggered runs fail with full-permission-actor-not-approved.

If you'd rather not grant Full permissions, keep selfSchedule: false and create a normal Apify Schedule for the Actor by hand — the polling logic is identical.

To stop self-scheduling, delete the schedule in the Console (or disable it there).

Pricing

This Actor uses Apify's pay-per-event model: $1 per 1,000 successful API checks ($0.001 per check). One "check" = one successful poll of the Hetzner auction feed; failed fetches are never charged. A poll every 10 minutes is 4,320 checks/month ($4.32/mo); every 30 minutes is 1,440 checks/month ($1.44/mo). You set your own max-charge cap on every run, so spend is always under your control. Notifications and dataset pushes are included — you only pay per check.

Local development

python -m venv .venv && source .venv/bin/activate
pip install -r requirements-dev.txt
pytest                 # unit tests (filter + state) against a saved sample feed
apify run              # run locally (needs the Apify CLI)

Self-scheduling and webhooks to Apify endpoints require a real run on the platform (apify push, then run from the Console).

Data source

Public internal endpoint: https://www.hetzner.com/_resources/app/data/app/live_data_sb_<EUR|USD>.json. It is undocumented and has changed shape before, so src/feed.py validates the structure on every run and fails loudly if it drifts.

FAQ

What is the Hetzner Server Auction (Serverbörse)? It's Hetzner's marketplace of pre-owned dedicated servers offered at reduced monthly prices with no setup fee. Inventory and prices fluctuate constantly as servers are claimed and released.

How fast will I be notified about a new deal? As fast as your poll interval. The default schedule checks every 10 minutes; lower the cron interval for tighter monitoring (at a slightly higher per-check cost).

Will I get duplicate alerts for the same server? No. The Actor remembers every listing it has already reported and only notifies you about servers it hasn't seen before.

Can I send alerts to Slack, Discord, or email? Yes — point genericWebhookUrl at any HTTP endpoint, including an automation platform (Make, Zapier, n8n) or a small relay that formats the JSON payload for Slack/Discord/email.

Do I need to keep the Actor running myself? No. Enable selfSchedule (with Full permissions) and it maintains its own recurring schedule, or create a standard Apify Schedule by hand.

Does it work with both EUR and USD pricing? Yes. Set currency to EUR or USD; all price filters are interpreted in that currency.