# Hetzner Server Auction Scraper (`automation-lab/hetzner-server-auction-monitor`) Actor

Filter and export current Hetzner dedicated-server auction offers with hardware, location, prices, and scheduled price-reduction timing.

- **URL**: https://apify.com/automation-lab/hetzner-server-auction-monitor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

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

```json
{
  "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

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

#### Falkenstein NVMe inventory

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

#### Price-reduction watchlist

```json
{
  "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:

```json
{
  "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

```bash
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

```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

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

```bash
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:

```json
{
  "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](https://apify.com/automation-lab/dataset-dedup) removes repeated records when consolidating scheduled snapshots.
- [Website HTML & Text Change Monitor](https://apify.com/automation-lab/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.

# Actor input Schema

## `maxItems` (type: `integer`):

Maximum number of matching server offers to save.

## `currency` (type: `string`):

Currency used for price filters, sorting, and output price fields.

## `maxMonthlyPrice` (type: `number`):

Keep offers at or below this monthly server price in the selected currency. IPv4 charges are reported separately.

## `maxSetupPrice` (type: `number`):

Keep offers at or below this one-time setup price in the selected currency. Use 0 for no setup fee.

## `minRamGb` (type: `number`):

Minimum total installed memory in gigabytes.

## `minStorageGb` (type: `number`):

Minimum combined capacity across all listed HDD, SATA SSD, and NVMe drives.

## `cpuQuery` (type: `string`):

Case-insensitive text that must appear in the CPU model, such as Ryzen or Xeon.

## `datacenters` (type: `array`):

Case-insensitive datacenter prefixes. Use FSN, NBG, or HEL for a region, or a full code such as FSN1-DC8.

## `storageTypes` (type: `array`):

Keep only offers containing every selected drive type.

## `requireEcc` (type: `boolean`):

When enabled, keep only servers whose memory is reported as ECC.

## `features` (type: `array`):

Case-insensitive keywords that must all appear in the offer details, such as GPU, IPv4, or iNIC.

## `maxPriceReductionHours` (type: `number`):

Keep only offers whose next scheduled auction price reduction is no more than this many hours away.

## `sortBy` (type: `string`):

Field used to order matching offers before the maximum result limit is applied.

## `sortDirection` (type: `string`):

Ascending returns the lowest or soonest values first; descending returns the highest or latest first.

## Actor input object example

```json
{
  "maxItems": 20,
  "currency": "EUR",
  "requireEcc": false,
  "sortBy": "monthlyPrice",
  "sortDirection": "asc"
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset view containing current auction hardware, locations, prices, and timing.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 20,
    "currency": "EUR"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hetzner-server-auction-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 20,
    "currency": "EUR",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hetzner-server-auction-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "currency": "EUR"
}' |
apify call automation-lab/hetzner-server-auction-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/hetzner-server-auction-monitor"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rwcCO2ZDgt4DYbgkw/builds/RhkF1dK9OlCHAh9bw/openapi.json