Hetzner Server Auction Scraper

Export current Hetzner Server Auction offers as clean, typed records for dedicated-server sourcing, inventory analysis, and scheduled price monitoring.

The Actor reads Hetzner's public structured auction feed, filters the complete current snapshot, and saves matching servers to an Apify dataset. Each result includes hardware, datacenter, rental and setup prices, IPv4 charges, bandwidth, features, and the next scheduled auction price reduction.

What does Hetzner Server Auction Scraper do?

The Actor turns the current Serverbörse inventory into analysis-ready records.

Use it to:

• find dedicated servers within a monthly budget;
• compare CPU, RAM, storage, and datacenter combinations;
• isolate NVMe, SATA SSD, HDD, ECC, GPU, IPv4, or iNIC offers;
• build procurement watchlists around upcoming price reductions;
• schedule inventory snapshots for change and price monitoring;
• send matching results to spreadsheets, databases, webhooks, or data pipelines.

It uses the public JSON data behind Hetzner's auction page. No Hetzner account, browser, proxy, or API key is required.

Who is this Actor for?

• Infrastructure teams comparing dedicated-server capacity and locations.
• Hosting providers watching inventory that fits resale or workload requirements.
• FinOps and procurement teams tracking monthly, hourly, setup, and IPv4 costs.
• Developers and data teams feeding current auction inventory into internal tools.
• Researchers analyzing hardware availability and price distribution over time.

The Actor returns a current snapshot. Use Apify schedules and your own stable key (serverId) when you need a time series or change alerts.

Why use this Actor?

• Structured source: reads public JSON rather than rendering a browser page.
• Detailed costs: keeps server, setup, and IPv4 charges separate and adds a monthly total.
• Hardware filters: combine RAM, total storage, drive type, CPU text, and ECC requirements.
• Location filters: accept broad prefixes such as FSN or exact codes such as FSN1-DC8.
• Auction timing: filter and sort by the next scheduled price reduction.
• Typed output: stable fields work directly in Apify integrations and API clients.
• Cost-efficient runs: one lightweight HTTP request retrieves the current inventory.

What data can I extract?

Field	Meaning
serverId	Stable Hetzner offer identifier
cpu, cpuCount	CPU model and source-reported CPU quantity
ramGb, ramModuleCount, ecc	Installed memory details
storageGb	Combined capacity of listed drives
storageDevices, storageTypes	Drive descriptions and NVMe/SATA/HDD groups
datacenter	Hetzner datacenter code
monthlyPrice, hourlyPrice	Server rental prices in the selected currency
setupPrice	One-time setup cost
ipv4Count, ipv4MonthlyPrice	Reported IPv4 quantity and monthly price
totalMonthlyPrice	Server monthly price plus IPv4 monthly cost
bandwidthMbps, traffic	Network bandwidth and traffic allowance
features, operatingSystems	Offer specials, hardware descriptions, and OS choices
nextPriceReductionAt	ISO timestamp for the next scheduled reduction
nextPriceReductionInSeconds	Remaining reduction countdown at scrape time
offerUrl, sourceUrl	Public auction and structured-feed links
scrapedAt	UTC time of the inventory snapshot

All prices in a record use its currency field. The maximum monthly-price filter applies to the server rental price; check totalMonthlyPrice when IPv4-inclusive cost is your decision metric.

Get started

1. Open the Actor input page.
2. Choose EUR or USD.
3. Add only the filters your procurement job needs.
4. Set maxItems to bound the output.
5. Select a sort field and direction.
6. Click Start.
7. Open the Server offers dataset view or export it as JSON, CSV, Excel, or XML.

A useful first run is:

{
  "currency": "EUR",
  "maxMonthlyPrice": 70,
  "maxItems": 20,
  "sortBy": "monthlyPrice",
  "sortDirection": "asc"
}

Input parameters

Parameter	Type	Default	Description
maxItems	integer	100	Maximum matching offers saved, from 1 to 1,000
currency	EUR or USD	EUR	Currency for filters, sorting, and output prices
maxMonthlyPrice	number	—	Maximum monthly server rental price
maxSetupPrice	number	—	Maximum one-time setup price; use 0 for no setup fee
minRamGb	number	—	Minimum installed RAM
minStorageGb	number	—	Minimum combined drive capacity
cpuQuery	string	—	Case-insensitive CPU-model substring
datacenters	string[]	—	Region prefixes or exact datacenter codes
storageTypes	string[]	—	Every selected type (nvme, sata, hdd) must be present
requireEcc	boolean	false	Require source-reported ECC memory
features	string[]	—	Every keyword must occur in the offer details
maxPriceReductionHours	number	—	Latest acceptable next-reduction countdown
sortBy	string	monthlyPrice	Price, RAM, storage, or next reduction
sortDirection	asc or desc	asc	Result ordering before maxItems is applied

Datacenter matching is case-insensitive and prefix-based. FSN matches all current Falkenstein datacenter codes, while FSN1-DC8 narrows the result to one code.

Filter examples

Cheapest servers under €70

{
  "currency": "EUR",
  "maxMonthlyPrice": 70,
  "maxItems": 20,
  "sortBy": "monthlyPrice",
  "sortDirection": "asc"
}

Falkenstein NVMe inventory

{
  "currency": "EUR",
  "datacenters": ["FSN"],
  "storageTypes": ["nvme"],
  "maxMonthlyPrice": 100,
  "maxItems": 20
}

Price-reduction watchlist

{
  "currency": "EUR",
  "minRamGb": 64,
  "minStorageGb": 2000,
  "maxMonthlyPrice": 120,
  "maxPriceReductionHours": 48,
  "maxItems": 25,
  "sortBy": "nextPriceReduction",
  "sortDirection": "asc"
}

Schedule the last input hourly or daily, then use an Apify webhook to trigger your comparison or notification workflow.

Output example

A current result has this shape:

{
  "serverId": 3060618,
  "cpu": "AMD Ryzen 7 PRO 1700X",
  "cpuCount": 1,
  "ramGb": 64,
  "ramModuleCount": 4,
  "ecc": false,
  "storageGb": 1536,
  "storageDevices": ["512 GB SSD", "512 GB SSD", "512 GB SSD"],
  "storageTypes": ["nvme", "sata"],
  "datacenter": "FSN1-DC8",
  "currency": "EUR",
  "monthlyPrice": 52,
  "hourlyPrice": 0.0834,
  "setupPrice": 0,
  "ipv4Count": 1,
  "ipv4MonthlyPrice": 1.7,
  "totalMonthlyPrice": 53.7,
  "bandwidthMbps": 1000,
  "traffic": "unlimited",
  "features": ["IPv4", "iNIC", "NVMe"],
  "operatingSystems": ["Rescue system"],
  "nextPriceReductionAt": "2026-08-23T10:12:00.000Z",
  "nextPriceReductionInSeconds": 151200,
  "offerUrl": "https://www.hetzner.com/sb/#search=3060618",
  "sourceUrl": "https://www.hetzner.com/_resources/app/data/app/live_data_sb.json",
  "scrapedAt": "2026-08-21T16:12:00.000Z"
}

Inventory and prices change continuously, so IDs and values shown here are illustrative of the live output contract rather than guaranteed current availability.

How much does it cost to monitor Hetzner Server Auction offers?

Pricing uses one start event after a successful inventory fetch plus one item event for each matching offer saved.

• Start fee: $0.005 per run.
• BRONZE item price: $0.0015968 per saved server offer.
• Item tiers decrease from $0.0018363 FREE through $0.0012455 SILVER, $0.00095808 GOLD, $0.00063872 PLATINUM, to $0.0004471 DIAMOND.
• Invalid inputs and failed upstream fetches do not produce item charges.

At BRONZE pricing:

Saved offers	BRONZE calculation
1	$0.005 + 1 × $0.0015968
20	$0.005 + 20 × $0.0015968
100	$0.005 + 100 × $0.0015968

Apify rounds and applies the active tier according to your account usage. Check the Actor pricing tab for the live tier available to you.

Build scheduled inventory monitoring

For recurring monitoring:

1. Save a focused input as an Apify Task.
2. Add an hourly, daily, or weekly schedule.
3. Use serverId as the stable record key.
4. Compare the newest dataset with your previous snapshot.
5. Trigger a webhook when an offer appears, disappears, or changes price.

The Actor does not retain cross-run state or send notifications itself. This keeps each run deterministic and lets you choose your own storage and alerting rules.

Export to spreadsheets and pipelines

From the dataset page, export results as JSON, CSV, Excel, XML, RSS, or JSONL.

Common workflows include:

• send the dataset to Google Sheets;
• load snapshots into BigQuery, Snowflake, or PostgreSQL;
• call a webhook after each scheduled run;
• join server offers with internal benchmark or capacity data;
• deduplicate records by serverId before downstream processing.

Use the Apify API

Replace <APIFY_TOKEN> with your token.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hetzner-server-auction-monitor/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"currency":"EUR","maxMonthlyPrice":70,"maxItems":20}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hetzner-server-auction-monitor').call({
    currency: 'EUR',
    datacenters: ['FSN'],
    storageTypes: ['nvme'],
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/hetzner-server-auction-monitor').call(run_input={
    'currency': 'EUR',
    'minRamGb': 64,
    'minStorageGb': 2000,
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use with MCP and AI agents

Add the Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/hetzner-server-auction-monitor"

Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/hetzner-server-auction-monitor"
    }
  }
}

Example prompts:

• “Find current Hetzner auction servers in HEL with at least 64 GB RAM.”
• “Export the 20 cheapest FSN NVMe offers in EUR.”
• “Create a watchlist of servers whose next price reduction is within 24 hours.”

Tips for reliable results

• Keep scheduled inputs stable so snapshots remain comparable.
• Use exact datacenter codes when region-wide inventory is too broad.
• Sort before applying a small maxItems to capture the most relevant offers.
• Treat monthlyPrice and totalMonthlyPrice separately when IPv4-inclusive budget matters.
• Inspect storageDevices as well as storageGb when drive count or RAID planning matters.
• Use scrapedAt as the snapshot time, not as the offer creation time.

Limitations

• Results reflect the public feed at fetch time; auction inventory can change immediately afterward.
• Hetzner does not expose historical snapshots through this Actor.
• cpuCount preserves the source-reported quantity and is not a derived physical-core benchmark.
• Storage capacity is summed from listed devices; no RAID-effective capacity is inferred.
• Feature matching searches source descriptions and does not infer unlisted capabilities.
• The Actor does not reserve, order, or modify servers.
• Automatic browser or residential-proxy fallback is intentionally not used.
• An upstream schema change causes a visible failed run instead of incomplete output.

Failure behavior and troubleshooting

Why did my run return zero offers?

The filters may not match the current inventory. Remove constraints one at a time, increase the budget, or use a broader datacenter prefix.

Why did the run fail with a feed error?

Hetzner's public feed may be temporarily unavailable or may have changed shape. The Actor retries transient network, rate-limit, and server errors. Schedule a later retry rather than treating an empty dataset as valid inventory.

Why is the total monthly price higher?

monthlyPrice is the server rental. totalMonthlyPrice adds the separately reported ipv4MonthlyPrice for all listed IPv4 addresses.

Why is an offer missing from a limited run?

Sorting happens before maxItems. Increase the limit or choose a sort that matches your workflow.

Legality and responsible use

This Actor reads public auction inventory without authentication. Use the data in accordance with Hetzner's terms, applicable law, and reasonable request practices.

Do not use results to misrepresent availability, automate abusive purchase behavior, or evade access controls. The Actor performs one lightweight feed request per run and does not collect personal data.

Hetzner is a trademark of its owner. This independent Actor is not affiliated with or endorsed by Hetzner Online GmbH.

Related Automation Lab Actors

• Dataset Deduplicator removes repeated records when consolidating scheduled snapshots.
• Website HTML & Text Change Monitor tracks general webpage changes when you need page-level monitoring rather than structured auction offers.

FAQ

Does it require a Hetzner account?

No. It reads the public Server Auction inventory feed.

Does it use Hetzner Cloud API credentials?

No. Hetzner Cloud instances and the dedicated Server Auction are different products; this Actor only exports public auction offers.

Can I monitor USD prices?

Yes. Set currency to USD; filters, sorting, and price fields will use the USD values supplied by Hetzner.

Can it order a matching server?

No. It exports public inventory for analysis and automation. Ordering remains on Hetzner's site.

Can I get historical price data?

Schedule repeated runs and retain their datasets in your own storage. The Actor returns only the current snapshot.

Are empty results charged per item?

No item event is emitted when no offers match. A successful inventory fetch still emits the one-time start event.