# Geizhals Price Comparison Scraper (`solidcode/geizhals-de-scraper`) Actor

\[💰 $1.0 / 1K] Scrape Geizhals (geizhals.de / .at / .eu) by keyword or URL. Get product names, brands, best prices, ratings, specifications and every merchant offer (shop, price, shipping, availability) from the leading DACH price-comparison platform.

- **URL**: https://apify.com/solidcode/geizhals-de-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 products

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Geizhals Price Comparison Scraper

Track product prices across the DACH region from Geizhals — Germany, Austria, and Europe's leading price-comparison platform — by plain keyword or by URL. Pull product names, brands, MPN/EAN identifiers, the lowest current price, total offer count, ratings, category paths, images, and (on demand) the full technical spec sheet plus every single merchant offer with shop name, price, shipping, and availability. Built for price-monitoring teams, e-commerce sellers, and deal hunters who need live DACH pricing without checking dozens of shops by hand.

### Why This Scraper?

- **3 country storefronts in one actor** — switch between Germany (geizhals.de), Austria (geizhals.at), and International (geizhals.eu) with a single dropdown; each store returns its own prices, merchant pool, and locale.
- **Every merchant offer per product, not just the headline price** — turn on full offers and every product that has competing shop offers is enriched with each shop's name, price, shipping/total price, availability, and a deep offer link, so you see the whole price ladder; products with no offers (such as variant overview pages) come back as clean price summaries.
- **Full technical specifications on demand** — the complete spec sheet (often 30+ key/value attributes per product) is captured alongside the offers for catalog building and comparison engines.
- **True server-side EUR price filtering** — a minimum and maximum price are applied at the source, not after the fact, so you only pay for products inside your target range.
- **MPN identifiers for catalog matching** — manufacturer part numbers come through on listing cards, making it straightforward to reconcile Geizhals products against your own SKU table.
- **Search by keyword OR direct URL** — type "grafikkarte", "ssd 1tb", or "kaffeevollautomat" and the search is built for you; or paste category, search-result, and product URLs directly and the type is auto-detected.
- **Best price plus full offer count on every row** — each product carries its lowest current price and the number of competing shops, even in fast summary mode with offers turned off.
- **Ratings and review counts** — average star rating and the number of buyer ratings are pulled per product wherever Geizhals shows them.
- **Automatic deduplication** — the same product is never returned twice, even when overlapping search terms and category URLs surface it more than once.

### Use Cases

**Price Monitoring & Repricing**
- Track the lowest price on your own products across every DACH merchant
- Watch competitor shops' prices and shipping on the same catalog item
- Feed live best-price data into automated repricing rules
- Compare a product's price spread from cheapest to most expensive offer

**Market & Competitive Research**
- Map an entire category's price distribution in Germany vs. Austria
- Benchmark how many merchants carry a given product
- Identify which shops consistently win the best-price slot
- Compare the same catalog across geizhals.de, .at, and .eu storefronts

**E-commerce & Catalog Building**
- Build product catalogs with names, brands, MPNs, images, and full specs
- Enrich existing listings with current best prices and offer counts
- Power comparison engines and buying guides with structured spec sheets
- Match Geizhals products to your inventory by manufacturer part number

**Deal Hunting & Lead Generation**
- Surface products dropping into a target EUR price window
- Find the cheapest merchant for a hot product before it sells out
- Build merchant contact and offer lists for high-demand categories
- Track availability so you only chase in-stock deals

### Getting Started

#### Search by Keyword

The simplest way to start — just a keyword:

```json
{
    "searchTerms": ["grafikkarte"],
    "maxResults": 50
}
````

#### Filter by Price Range

Only return products inside a EUR window, on the Austrian store:

```json
{
    "searchTerms": ["ssd 1tb"],
    "domain": "geizhals.at",
    "minPrice": 50,
    "maxPrice": 150,
    "maxResults": 100
}
```

#### Full Offers & Specifications

Open every product to pull all merchant offers plus the complete spec sheet:

```json
{
    "searchTerms": ["kaffeevollautomat"],
    "includeOffers": true,
    "maxResults": 100
}
```

#### Using Geizhals URLs

Paste category, search-result, or product URLs directly — the type is detected automatically:

```json
{
    "startUrls": [
        "https://geizhals.de/?cat=gra16_512",
        "https://geizhals.de/asus-prime-radeon-rx-9070-xt-a3430251.html"
    ],
    "includeOffers": true,
    "maxResults": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["grafikkarte"]` | Plain keywords to search Geizhals for (e.g. "grafikkarte", "ssd 1tb", "kaffeevollautomat"). The search is built for you — no URLs needed. Add as many terms as you like. |
| `startUrls` | string\[] | `[]` | Paste Geizhals links directly: category pages, search-result pages, or individual product pages. The type is detected automatically. |
| `domain` | select | `Germany (geizhals.de)` | Which Geizhals store to use: Germany (geizhals.de), Austria (geizhals.at), or International (geizhals.eu). Sets prices, merchants, and language. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minPrice` | integer | — | Only return products priced at or above this amount in EUR. Leave empty for no minimum. |
| `maxPrice` | integer | — | Only return products priced at or below this amount in EUR. Leave empty for no maximum. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of products to return in total, across all search terms and URLs. Set to 0 to collect everything available. Products are collected a full page (about 30) at a time, so the count is rounded up to the end of the last page — asking for 15 may return 30, and every returned product is billed. Start with 20-100 to test, then increase. |
| `includeOffers` | boolean | `false` | When on, every product that has competing shop offers is enriched with its full merchant list (shop name, price, shipping, total price, availability), the complete specifications, and a product description. Every offer such a product currently has is returned, up to a safety limit of about 1,000 offers per product. Products with no offers — such as variant overview pages — are returned as price summaries. Slower and much richer. When off, you get the product summary and best price only. |

### Output

One row per product. With `includeOffers` on, each row carries a nested `offers` array and a `specifications` object. Here is a representative result with full offers enabled:

```json
{
    "name": "ASUS Prime Radeon RX 9070 XT",
    "brand": "ASUS",
    "productId": "a3430251",
    "url": "https://geizhals.de/asus-prime-radeon-rx-9070-xt-a3430251.html",
    "bestPrice": 657.90,
    "currency": "EUR",
    "priceRange": { "min": 657.90, "max": 999.00 },
    "offerCount": 43,
    "rating": 4.5,
    "reviewCount": 128,
    "category": "Hardware > Grafikkarten > PCIe",
    "image": "https://gzhls.at/i/12/34/3430251-1.jpg",
    "mpn": "90YV0...",
    "availability": "Lagernd",
    "description": "Preisvergleich für ASUS Prime Radeon RX 9070 XT OC — Modell: AMD Radeon RX 9070 XT • Speicher: 16GB GDDR6, 256bit, 20Gbps",
    "specifications": {
        "Chip": "AMD Radeon RX 9070 XT",
        "Speicher": "16GB GDDR6",
        "Anschlüsse": "3x DisplayPort 2.1, 1x HDMI 2.1"
    },
    "offers": [
        {
            "merchant": "BA-Computer",
            "price": 657.90,
            "shipping": "zzgl. Versand",
            "totalPrice": 657.90,
            "availability": "Lagernd, Lieferung 1-3 Tage",
            "offerUrl": "https://geizhals.de/redirect/...",
            "sku": "GPU-90YV0"
        }
    ],
    "domain": "geizhals.de",
    "scrapedAt": "2026-06-27T14:30:00Z"
}
```

#### Core Product

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Product name/title |
| `brand` | string | Manufacturer / brand |
| `productId` | string | Geizhals internal product id |
| `url` | string | Canonical Geizhals product URL |
| `mpn` | string | Manufacturer part number, where shown |
| `category` | string | Category breadcrumb path (e.g. "Hardware > Grafikkarten > PCIe") |
| `image` | string | Main product image URL |
| `rating` | number | Average product rating, where shown |
| `reviewCount` | integer | Number of buyer ratings |
| `domain` | string | Store the row came from (geizhals.de / .at / .eu) |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `bestPrice` | number | Lowest current price (EUR) |
| `currency` | string | Price currency (EUR) |
| `priceRange` | object | `{ min, max }` price across merchants, when available |
| `offerCount` | integer | Number of merchant offers Geizhals lists |
| `availability` | string | Stock/availability summary for the best offer |

#### Offer Item (inside `offers[]`, when full offers are on)

| Field | Type | Description |
|-------|------|-------------|
| `merchant` | string | Shop name |
| `price` | number | Offer price (EUR) |
| `shipping` | string | Shipping / payment note |
| `totalPrice` | number | Total price for the offer |
| `availability` | string | Delivery/availability for this shop |
| `offerUrl` | string | Deep link to the merchant offer |
| `sku` | string | Shop SKU/order detail, where present |

All of a product's current offers are returned (up to a safety limit of about 1,000 offers per product).

#### Description & Specifications (when full offers are on)

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Short product description / summary (model and key specs) |
| `specifications` | object | Key/value map of the full technical spec sheet (chip, memory, ports, etc.) |

The `category` breadcrumb path is also populated when full offers are on (it comes from the product page).

### Tips for Best Results

- **Start small** — set `maxResults` to 20-100 on your first run to confirm the data matches your needs, then scale up.
- **Leave offers off for fast catalog sweeps** — keep `includeOffers` off when you only need names, best prices, and offer counts; turn it on only when you actually need the full merchant list and spec sheet. It is much faster and lighter that way.
- **Match the store to your market** — geizhals.de, geizhals.at, and geizhals.eu return different merchant pools and prices, so pick the store that reflects the buyers you care about.
- **Use the EUR price filter to cut noise** — `minPrice`/`maxPrice` are applied at the source, so narrowing the window keeps results on-target and your run lean.
- **Mix keywords and URLs in one run** — combine several search terms with pasted category or product URLs; duplicates are removed automatically.
- **Drop in a product URL for a single deep dive** — paste one product URL with `includeOffers` on to get that product's entire offer ladder and full specs in one shot.
- **Set `maxResults` to 0 for a full category** — when you want everything in a category or search, leave the cap at 0 and the scraper paginates to the end.

### Pricing

**From $1.00 per 1,000 products** — competitive with the DACH price-comparison market. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Products | No discount | Bronze | Silver | Gold |
|----------|-------------|--------|--------|------|
| 100 | $0.12 | $0.11 | $0.11 | $0.10 |
| 1,000 | $1.20 | $1.13 | $1.06 | $1.00 |
| 10,000 | $12.00 | $11.30 | $10.60 | $10.00 |
| 100,000 | $120.00 | $113.00 | $106.00 | $100.00 |

**Full offers add-on.** Turning on full merchant offers adds a surcharge of about $6.00 per 1,000 offer-enriched products, charged only for products that actually return offers. Pulling every merchant's price, shipping, and availability for a product is far heavier than the product summary, so the add-on is billed separately and only when offers are delivered. For example: 100 products with full offers, of which ~40 return a merchant list ≈ $0.10 (products) + $0.24 (offers) = $0.34 total.

A "product" is any product row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Volume discount tiers (Bronze, Silver, Gold) apply automatically on the Apify platform.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate price monitoring, market research, and catalog building. You are responsible for complying with applicable laws and Geizhals' Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and be mindful of how you store and process any data you collect. </content> </invoke>

# Actor input Schema

## `searchTerms` (type: `array`):

Type plain keywords to search Geizhals for, such as 'grafikkarte', 'ssd 1tb' or 'kaffeevollautomat'. We build the search for you — no need to create URLs. Add as many terms as you like.

## `startUrls` (type: `array`):

Paste Geizhals links directly: category pages, search-result pages, or individual product pages. The type is detected automatically. Use this if you already have the exact pages you want.

## `domain` (type: `string`):

Which Geizhals store to use. This sets the prices, available merchants and the language: Germany (geizhals.de), Austria (geizhals.at) or International (geizhals.eu).

## `maxResults` (type: `integer`):

Maximum number of products to return in total, across all search terms and URLs. Set to 0 to collect everything available. Products are collected a full page (about 30) at a time, so the final count is rounded up to the end of the last page — asking for 15 may return 30. Every returned product is billed. Tip: start with 20-100 to test, then increase.

## `includeOffers` (type: `boolean`):

When on, every product that has competing shop offers is enriched with its full merchant list (shop name, price, shipping, total price, availability), the complete specifications, and a product description. We return every offer such a product currently has, up to a safety limit of about 1,000 offers per product. Products with no offers — such as variant overview pages that just group related models — are returned as price summaries (name, brand, best price, offer count, rating). This is slower and returns much more data. When off, you get the product summary and the best (lowest) price only.

## `minPrice` (type: `integer`):

Only return products priced at or above this amount, in euros. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Only return products priced at or below this amount, in euros. Leave empty for no maximum.

## Actor input object example

```json
{
  "searchTerms": [
    "grafikkarte"
  ],
  "startUrls": [],
  "domain": "geizhals.de",
  "maxResults": 100,
  "includeOffers": false
}
```

# Actor output Schema

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

Table of scraped Geizhals products with name, brand, best price, offer count, rating and category.

# 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 = {
    "searchTerms": [
        "grafikkarte"
    ],
    "startUrls": [],
    "domain": "geizhals.de",
    "maxResults": 100,
    "includeOffers": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/geizhals-de-scraper").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 = {
    "searchTerms": ["grafikkarte"],
    "startUrls": [],
    "domain": "geizhals.de",
    "maxResults": 100,
    "includeOffers": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/geizhals-de-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "grafikkarte"
  ],
  "startUrls": [],
  "domain": "geizhals.de",
  "maxResults": 100,
  "includeOffers": false
}' |
apify call solidcode/geizhals-de-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/geizhals-de-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Geizhals Price Comparison Scraper",
        "description": "[💰 $1.0 / 1K] Scrape Geizhals (geizhals.de / .at / .eu) by keyword or URL. Get product names, brands, best prices, ratings, specifications and every merchant offer (shop, price, shipping, availability) from the leading DACH price-comparison platform.",
        "version": "1.0",
        "x-build-id": "nP9tVE6RdyKqbWlFU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~geizhals-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-geizhals-de-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~geizhals-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-geizhals-de-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~geizhals-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-geizhals-de-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Type plain keywords to search Geizhals for, such as 'grafikkarte', 'ssd 1tb' or 'kaffeevollautomat'. We build the search for you — no need to create URLs. Add as many terms as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Geizhals URLs",
                        "type": "array",
                        "description": "Paste Geizhals links directly: category pages, search-result pages, or individual product pages. The type is detected automatically. Use this if you already have the exact pages you want.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "domain": {
                        "title": "Store",
                        "enum": [
                            "geizhals.de",
                            "geizhals.at",
                            "geizhals.eu"
                        ],
                        "type": "string",
                        "description": "Which Geizhals store to use. This sets the prices, available merchants and the language: Germany (geizhals.de), Austria (geizhals.at) or International (geizhals.eu).",
                        "default": "geizhals.de"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to return in total, across all search terms and URLs. Set to 0 to collect everything available. Products are collected a full page (about 30) at a time, so the final count is rounded up to the end of the last page — asking for 15 may return 30. Every returned product is billed. Tip: start with 20-100 to test, then increase.",
                        "default": 100
                    },
                    "includeOffers": {
                        "title": "Include all merchant offers & full specifications",
                        "type": "boolean",
                        "description": "When on, every product that has competing shop offers is enriched with its full merchant list (shop name, price, shipping, total price, availability), the complete specifications, and a product description. We return every offer such a product currently has, up to a safety limit of about 1,000 offers per product. Products with no offers — such as variant overview pages that just group related models — are returned as price summaries (name, brand, best price, offer count, rating). This is slower and returns much more data. When off, you get the product summary and the best (lowest) price only.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products priced at or above this amount, in euros. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products priced at or below this amount, in euros. Leave empty for no maximum."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```