# mydealz.de Scraper (`solidcode/mydealz-de-scraper`) Actor

\[💰 $0.55 / 1K] Scrape deals from mydealz.de, Germany's biggest deals community. Search by keyword, browse a category, or paste URLs to get prices, discounts, voucher codes, hotness scores, merchants, and posters.

- **URL**: https://apify.com/solidcode/mydealz-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 $0.55 / 1,000 results

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

## mydealz.de Scraper

Pull live deals from mydealz.de — Germany's biggest deals and discount community — with prices, voucher codes, next-best-price comparisons, merchant names, and the community "temperature" (hotness) score on every record. Type a keyword, pick a category, or paste any mydealz URL and get back a clean, structured deal feed. Built for deal resellers, price-comparison sites, and German e-commerce market researchers who need fresh, sortable bargain data without manually monitoring hundreds of deal threads a day.

### Why This Scraper?

- **Community temperature on every deal** — the live mydealz hotness score (e.g. `1679°`) plus a `temperatureLevel` band, so you can rank deals by how hard the community is actually upvoting them, not just by recency.
- **Voucher and coupon codes captured** — when a deal carries a discount code (`voucherCode`), you get the exact code in its own field, ready to test, resell, or feed into a coupon site.
- **Next-best-price comparison built in** — every record pairs the current `price` with `nextBestPrice` (the reference price elsewhere) and a `discountPercent`, so the size of the saving is calculated for you.
- **24 structured fields per deal** — title, price, discount, merchant, voucher, temperature, comment count, poster, timestamps, expired/hot/pinned flags, image, and more — one flat row per deal, no nested digging.
- **15 curated German categories** — Electronics, Computers, Phones & Contracts, Gaming, Home & Living, Fashion & Accessories, Groceries & Food, Drugstore & Beauty, Family & Kids, Leisure & Culture, Travel, Auto & Motorcycle, Garden & DIY, Sports & Fitness, and Vouchers & Coupons — browse one with a single dropdown choice.
- **Hotness threshold and recency filters** — set a `minTemperature` (e.g. `500°`) to collect only deals the community has already pushed past that bar, and a `maxAgeDays` window (e.g. last `7` days) to keep just the freshest drops, skipping the long tail of lukewarm or stale posts.
- **3 sort modes** — Hottest, Newest First, or Most Discussed — so you can chase trending bargains, catch brand-new drops the moment they post, or mine the most-debated threads.
- **Three ways in, zero URL-building** — search by keyword, browse a category from a dropdown, or paste any mydealz search, category, group, or single-deal URL; mix all three in one run.
- **Merchant and poster metadata** — every deal ships the retailer name (`merchant`), an outbound merchant link, the poster's username and ID, and the thread's `commentCount`, ready for lead, attribution, or community analysis.

### Use Cases

**Reselling & Arbitrage**
- Spot underpriced electronics, Lego, and gaming deals the moment they go hot for flip-and-resell margins.
- Filter by `minTemperature` to surface only crowd-validated bargains worth acting on fast.
- Track `voucherCode` drops to stack discounts before they expire.

**Price Intelligence**
- Compare `price` against `nextBestPrice` and `discountPercent` to benchmark how aggressive a retailer's offer really is.
- Monitor a category daily to map the German market's pricing floor for a product class.
- Feed structured deal records into your own price-tracking or repricing engine.

**Market & Consumer Research**
- Measure demand signals by tracking which deals rack up the highest temperature and comment counts.
- Study seasonal discount patterns across 15 categories of the German retail market.
- Identify which merchants the mydealz community trusts and engages with most.

**Affiliate & Content**
- Source fresh, high-temperature deals to populate bargain newsletters, blogs, and deal-of-the-day pages.
- Pull voucher codes and merchant links to build always-current coupon and offer roundups.
- Sort by Newest First to publish hot drops minutes after the community spots them.

**Competitive Monitoring**
- Watch a competitor's products surface (or get torn apart) in deal threads via comment counts and temperature.
- Track when and where a brand's discounts appear across categories and merchants.
- Catch expired deals with the `includeExpired` toggle to reconstruct full promotional histories.

### Getting Started

#### Simple keyword search

```json
{
  "searchQueries": ["iPhone"],
  "maxResults": 50
}
````

#### Browse a whole category

```json
{
  "category": "gaming",
  "sortBy": "hot",
  "maxResults": 100
}
```

#### Hot, crowd-validated deals only

```json
{
  "searchQueries": ["Lego", "Nintendo Switch"],
  "category": "family-kids",
  "sortBy": "hot",
  "minTemperature": 500,
  "includeExpired": false,
  "maxResults": 200
}
```

#### Paste mydealz URLs directly

```json
{
  "startUrls": [
    "https://www.mydealz.de/gruppe/elektronik",
    "https://www.mydealz.de/search?q=Kaffeevollautomat"
  ],
  "maxResults": 150
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["iPhone"]` | Keywords to search mydealz for, e.g. `iPhone`, `Lego`, `Nintendo Switch`. Each keyword runs its own search. Leave empty to browse a category or paste URLs instead. |
| `startUrls` | array | `[]` | Paste mydealz.de URLs directly — works with category/group pages, search-result pages, and single deal pages. Any filters already in the URL are applied automatically. |

#### Search Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | select | `All deals` | Limit keyword searches to one mydealz category. Options: All deals, Electronics, Computers, Phones & Contracts, Gaming, Home & Living, Fashion & Accessories, Groceries & Food, Drugstore & Beauty, Family & Kids, Leisure & Culture, Travel, Auto & Motorcycle, Garden & DIY, Sports & Fitness, Vouchers & Coupons. Ignored for pasted URLs. |
| `sortBy` | select | `Hottest` | Order deals are collected in: Hottest, Newest First, or Most Discussed. Applies to keyword/category searches only. |
| `includeExpired` | boolean | `false` | Include deals already marked expired. Leave off to collect only active, still-available deals. |
| `minTemperature` | integer | `0` | Only return deals at or above this hotness score (mydealz temperature, e.g. `100` = 100°). Higher means more popular. Leave at 0 for no threshold. |
| `maxAgeDays` | integer | *(none)* | Only return deals posted within the last N days (e.g. `7` keeps the past week). Leave empty to collect deals of any age. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of deals to collect across all keywords and URLs combined, up to 100,000 per run. Set to 0 for unlimited. Tip: start with 20–50 to test, then increase. |

### Output

Each deal is returned as one flat record. Example:

```json
{
  "dealId": "2803002",
  "title": "Apple iPhone 15 128GB",
  "url": "https://www.mydealz.de/deals/apple-iphone-15-128gb-2803002",
  "merchantUrl": "https://www.mydealz.de/visit/threadmain/2803002",
  "price": 599.0,
  "nextBestPrice": 729.0,
  "discountPercent": 18.0,
  "shipping": 0,
  "currency": "EUR",
  "voucherCode": "APPLE20",
  "merchant": "Amazon",
  "category": "Elektronik",
  "temperature": 1679.06,
  "temperatureLevel": "hot",
  "commentCount": 142,
  "posterUsername": "schnaeppchenjaeger",
  "posterUserId": "884213",
  "publishedAt": "2026-06-25T08:14:00Z",
  "updatedAt": "2026-06-25T11:02:00Z",
  "isExpired": false,
  "isHot": true,
  "isPinned": false,
  "imageUrl": "https://static.mydealz.de/threads/raw/iphone15/iphone15.jpg",
  "scrapedAt": "2026-06-26T09:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `dealId` | string | Unique mydealz deal/thread identifier. |
| `title` | string | Deal title as posted to the community. |
| `url` | string | Canonical mydealz deal URL. |
| `merchantUrl` | string | Outbound link to the merchant's offer. |
| `merchant` | string | Retailer / vendor name (e.g. Amazon, MediaMarkt). |
| `category` | string | mydealz category the deal belongs to. |
| `imageUrl` | string | Deal thumbnail image URL. |

#### Pricing & Discounts

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Current deal price. |
| `nextBestPrice` | number | Reference / comparison price elsewhere. |
| `discountPercent` | number | Listed discount percentage (0 when not applicable). |
| `shipping` | number | Shipping cost (0 = free shipping). |
| `currency` | string | Currency code (always EUR). |
| `voucherCode` | string | Voucher / discount code if the deal carries one. |

#### Community & Engagement

| Field | Type | Description |
|-------|------|-------------|
| `temperature` | number | Community hotness score in degrees (°). |
| `temperatureLevel` | string | Hotness tier label for the deal. |
| `commentCount` | integer | Number of comments on the deal thread. |
| `posterUsername` | string | Username of the member who posted the deal. |
| `posterUserId` | string | Unique ID of the poster. |

#### Status & Timestamps

| Field | Type | Description |
|-------|------|-------------|
| `isExpired` | boolean | Whether the deal is marked expired. |
| `isHot` | boolean | Whether the deal is currently trending. |
| `isPinned` | boolean | Whether the deal is pinned / sponsored. |
| `publishedAt` | string | When the deal was posted (ISO 8601, UTC). |
| `updatedAt` | string | When the deal was last updated (ISO 8601, UTC). |
| `scrapedAt` | string | When this record was collected (ISO 8601, UTC). |

### Tips for Best Results

- **Sort by Hottest and set a `minTemperature`** to capture only the deals the community is actively upvoting — this is the single best filter for surfacing genuinely good bargains and cutting noise.
- **Start small to validate, then scale** — run with `maxResults` of 20–50 first to confirm your keyword and category, then raise the cap once the results look right.
- **Use Newest First for time-sensitive flips** — hot deals on mydealz can sell out within minutes, so sorting by newest lets you catch drops the moment they post.
- **Combine a keyword with a category** to narrow a broad term — searching `Monitor` inside Electronics returns far cleaner results than the keyword alone.
- **Turn on Include Expired Deals for historical research** — expired deals are excluded by default, but they're invaluable for reconstructing a merchant's full promotional history.
- **Paste a category or group URL when you want everything in a section** — pasted URLs keep their own built-in filters, so a category page already sorted or filtered on the site carries those settings over.
- **Filter on `voucherCode` after the run** to instantly isolate every deal that ships with a coupon — ideal for building coupon roundups.

### Pricing

**From $0.55 per 1,000 results** — competitively priced for high-volume deal monitoring. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.065 | $0.061 | $0.058 | $0.055 |
| 1,000 | $0.65 | $0.61 | $0.58 | $0.55 |
| 10,000 | $6.50 | $6.10 | $5.80 | $5.50 |
| 100,000 | $65.00 | $61.00 | $58.00 | $55.00 |

A "result" is one deal record returned to your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### 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 deals
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available deal information from mydealz.de for legitimate research, price-comparison, and market-analysis purposes. Use the data responsibly: respect mydealz.de's terms of service, do not overload the source, and comply with all applicable laws including data-protection regulations such as the GDPR. Do not use collected personal data (such as poster usernames) for spam, harassment, or any purpose that infringes on individuals' privacy. You are responsible for ensuring your use of this data complies with the law in your jurisdiction.

# Actor input Schema

## `searchQueries` (type: `array`):

What to search mydealz for, e.g. 'iPhone', 'Lego', 'Nintendo Switch'. Each keyword runs its own search. Leave empty to browse a category below or to paste mydealz URLs instead.

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

Paste mydealz.de URLs directly — works with category/group pages (e.g. https://www.mydealz.de/gruppe/elektronik-deals), search-result pages, and single deal pages. Any filters already in the URL (category, sort, keyword) are applied automatically. Mix as many URLs as you like.

## `category` (type: `string`):

Limit keyword searches to one mydealz category. Only applies to Search Keywords — ignored for URLs, which carry their own category. Leave on 'All deals' to search everything.

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

Order in which keyword/category deals are collected. Only applies to Search Keywords and the category — pasted URLs keep their own sort order.

## `includeExpired` (type: `boolean`):

Include deals that are already marked expired (abgelaufen). Leave off to collect only active, still-available deals.

## `minTemperature` (type: `integer`):

Only return deals at or above this hotness score (mydealz 'temperature', e.g. 100 = 100°). Higher means more popular. Leave empty for no threshold.

## `maxAgeDays` (type: `integer`):

Only return deals posted within the last N days, based on when the deal was first posted. For example, 7 keeps only deals from the past week. Leave empty to collect deals of any age.

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

Maximum number of deals to collect across all keywords and URLs combined, up to 100,000 per run. Set to 0 for unlimited — each source then scans up to 500 pages (a large but finite ceiling that keeps long runs from spinning forever). Tip: start with 20-50 to test, then increase.

## Actor input object example

```json
{
  "searchQueries": [
    "iPhone"
  ],
  "startUrls": [],
  "category": "",
  "sortBy": "hot",
  "includeExpired": false,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped mydealz deals with key fields.

# 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 = {
    "searchQueries": [
        "iPhone"
    ],
    "startUrls": [],
    "category": "",
    "sortBy": "hot",
    "includeExpired": false,
    "minTemperature": 0,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/mydealz-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 = {
    "searchQueries": ["iPhone"],
    "startUrls": [],
    "category": "",
    "sortBy": "hot",
    "includeExpired": False,
    "minTemperature": 0,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/mydealz-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 '{
  "searchQueries": [
    "iPhone"
  ],
  "startUrls": [],
  "category": "",
  "sortBy": "hot",
  "includeExpired": false,
  "minTemperature": 0,
  "maxResults": 100
}' |
apify call solidcode/mydealz-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "mydealz.de Scraper",
        "description": "[💰 $0.55 / 1K] Scrape deals from mydealz.de, Germany's biggest deals community. Search by keyword, browse a category, or paste URLs to get prices, discounts, voucher codes, hotness scores, merchants, and posters.",
        "version": "1.0",
        "x-build-id": "X4Q69ICEHn00JXFNq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~mydealz-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-mydealz-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~mydealz-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-mydealz-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~mydealz-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-mydealz-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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "maxItems": 50,
                        "type": "array",
                        "description": "What to search mydealz for, e.g. 'iPhone', 'Lego', 'Nintendo Switch'. Each keyword runs its own search. Leave empty to browse a category below or to paste mydealz URLs instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct mydealz URLs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Paste mydealz.de URLs directly — works with category/group pages (e.g. https://www.mydealz.de/gruppe/elektronik-deals), search-result pages, and single deal pages. Any filters already in the URL (category, sort, keyword) are applied automatically. Mix as many URLs as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "elektronik",
                            "computer",
                            "handyvertraege",
                            "gaming",
                            "home-living",
                            "fashion-accessoires",
                            "food",
                            "beauty",
                            "family-kids",
                            "kultur-freizeit",
                            "reisen",
                            "auto-motorrad",
                            "garten-baumarkt",
                            "sport",
                            "coupons"
                        ],
                        "type": "string",
                        "description": "Limit keyword searches to one mydealz category. Only applies to Search Keywords — ignored for URLs, which carry their own category. Leave on 'All deals' to search everything.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort Deals By",
                        "enum": [
                            "hot",
                            "new",
                            "discussed"
                        ],
                        "type": "string",
                        "description": "Order in which keyword/category deals are collected. Only applies to Search Keywords and the category — pasted URLs keep their own sort order.",
                        "default": "hot"
                    },
                    "includeExpired": {
                        "title": "Include Expired Deals",
                        "type": "boolean",
                        "description": "Include deals that are already marked expired (abgelaufen). Leave off to collect only active, still-available deals.",
                        "default": false
                    },
                    "minTemperature": {
                        "title": "Minimum Temperature",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return deals at or above this hotness score (mydealz 'temperature', e.g. 100 = 100°). Higher means more popular. Leave empty for no threshold."
                    },
                    "maxAgeDays": {
                        "title": "Posted Within (Days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only return deals posted within the last N days, based on when the deal was first posted. For example, 7 keeps only deals from the past week. Leave empty to collect deals of any age."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of deals to collect across all keywords and URLs combined, up to 100,000 per run. Set to 0 for unlimited — each source then scans up to 500 pages (a large but finite ceiling that keeps long runs from spinning forever). Tip: start with 20-50 to test, then increase.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
