# Telefonbuch.de Scraper - German Directory & Phone Lookup (`trev0n/telefonbuch-de-scraper`) Actor

Scrape Das Telefonbuch (telefonbuch.de) — Germany's phone book. Search businesses by keyword & city, people by last name, or reverse phone lookup. Get full phone numbers, decoded emails, websites, opening hours, GPS and ratings. Incremental monitoring for cheap recurring runs.

- **URL**: https://apify.com/trev0n/telefonbuch-de-scraper.md
- **Developed by:** [Paweł](https://apify.com/trev0n) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 search result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 📞 Telefonbuch.de Scraper

🎯 **Turn Germany's national phone book into a clean, ready-to-use contact database — businesses, people and reverse phone lookups, all in one place.**

This scraper pulls structured records from **Das Telefonbuch (telefonbuch.de / dastelefonbuch.de)**: company name, full street address, the **complete phone number**, category, decoded email address, website, fax, opening hours, GPS coordinates and ratings. Search by business keyword and city, by a person's last name, or run a reverse lookup to find out who owns a phone number.

### 🚀 What Does It Do?

This scraper automatically searches Das Telefonbuch and collects **structured, ready-to-use data** — no manual browsing, no copy-pasting numbers one by one. Just set your search and hit Start.

💡 **Three ways to search:**

1. **🏢 Business search** — find companies by keyword/category (e.g. _Friseur_, _Zahnarzt_, _Restaurant_) in any German city, or nationwide.
2. **👤 People search** — look up private phone-book entries by last name, optionally narrowed to a city.
3. **🔁 Reverse phone lookup** — paste a phone number and find out who it belongs to.

📋 **Or use Direct URL Mode** — paste any telefonbuch.de search or entry page and it's picked up automatically.

### 👥 Who Is This For?

| 🏢 Use Case                        | 💬 How It Helps                                                                                  |
| ---------------------------------- | ------------------------------------------------------------------------------------------------ |
| 📣 **Sales & lead generation**     | Build targeted B2B contact lists by industry and city — names, phones and emails ready to import |
| 📊 **Market researchers**          | Map how many businesses of a given type operate in each region                                   |
| 🤝 **Recruiters & agencies**       | Quickly source local business contacts for outreach campaigns                                    |
| 🗂️ **CRM & data teams**            | Enrich and verify existing records with fresh addresses, phones and websites                     |
| 🔎 **Investigators & journalists** | Reverse-lookup unknown numbers and confirm business details                                      |
| 🏘️ **Local service providers**     | Scout competitors and partners in your own city                                                  |

### ✨ Features

- 🏢 **Business, people & reverse search** — three modes in one actor
- 📞 **Complete phone numbers** — reconstructs the full number the site tries to hide
- 📧 **Decoded emails** — recovers protected email addresses automatically
- 🌐 **Websites, fax & opening hours** — the full contact profile when you enable details
- 📍 **GPS coordinates** — exact latitude/longitude for mapping and routing
- ⭐ **Ratings & reviews** — aggregate score plus per-source breakdown (golocal, 11880, and more)
- 🇩🇪 **Nationwide or city-scoped** — search a single town or all of Germany
- 🎛️ **Smart Filters** — search type, keyword, city, result caps and detail depth
- 🔄 **Incremental Monitoring** — recurring runs return only what changed, typically 80–95% cheaper
- ♻️ **Deduplication** — every entry appears once, even across paginated results
- ⚡ **Fast & Scalable** — hundreds of records per run, no proxy required
- 📤 **Export Anywhere** — Download results as JSON, CSV, Excel, or push to Google Sheets, Zapier, Make, or your CRM

### 🎛️ Filters & Options

| Option                        | What It Does                                                            |
| ----------------------------- | ----------------------------------------------------------------------- |
| 🔀 **Search Type**            | Choose businesses, people, or reverse phone lookup                      |
| 🏷️ **Search Query**           | The business keyword, last name, or phone number to look up             |
| 🏙️ **Location**               | Narrow the search to a German city (leave empty for nationwide)         |
| 📖 **Fetch Full Details**     | Open each entry for email, website, fax, opening hours, GPS and ratings |
| 🔄 **Incremental Monitoring** | Return only new/changed entries on recurring runs                       |
| 🔢 **Max Results**            | Control how many entries to extract per run                             |
| 🔗 **Direct URLs**            | Optionally paste specific telefonbuch.de URLs to scrape                 |

### 📦 What You Get (Output Fields)

Every entry includes:

#### 🪪 Identity

| Field      | Example                                                                                         |
| ---------- | ----------------------------------------------------------------------------------------------- |
| entryId    | `0001129856758`                                                                                 |
| recordType | `business`                                                                                      |
| name       | `Adlon Holding GmbH`                                                                            |
| category   | `Hotels Berlin`                                                                                 |
| detailUrl  | `https://adresse.dastelefonbuch.de/Berlin/1-Hotels-Adlon-Holding-GmbH-Berlin-Friedrichstr.html` |

#### 📞 Contact

| Field   | Example                       |
| ------- | ----------------------------- |
| phone   | `030 30 11 17-0`              |
| fax     | `030 30 11 17-77`             |
| email   | `info@adlon-holding.de`       |
| emails  | `["info@adlon-holding.de"]`   |
| website | `http://www.adlon-holding.de` |

#### 📍 Address & Location

| Field      | Example            |
| ---------- | ------------------ |
| street     | `Friedrichstr. 71` |
| postalCode | `10117`            |
| city       | `Berlin`           |
| district   | `Mitte`            |
| latitude   | `52.513263`        |
| longitude  | `13.389743`        |

#### 🕑 Hours & Ratings

| Field         | Example                                                                                       |
| ------------- | --------------------------------------------------------------------------------------------- |
| openingHours  | `["Mo 09:00-17:00", "Tu 09:00-17:00"]`                                                        |
| openStatus    | `Geschlossen`                                                                                 |
| ratingValue   | `5.0`                                                                                         |
| ratingCount   | `1`                                                                                           |
| ratingSources | `[{ "source": "11880", "score": 5.0, "reviewCount": 1, "url": "https://www.11880.com/..." }]` |

### 📊 Example Output

```json
{
    "entryId": "0001129856758",
    "recordType": "business",
    "name": "Adlon Holding GmbH",
    "category": "Hotels Berlin",
    "phone": "030 30 11 17-0",
    "fax": null,
    "email": "info@adlon-holding.de",
    "emails": ["info@adlon-holding.de"],
    "website": "http://www.adlon-holding.de",
    "street": "Friedrichstr. 71",
    "postalCode": "10117",
    "city": "Berlin",
    "district": "Mitte",
    "latitude": 52.513263,
    "longitude": 13.389743,
    "openingHours": ["Mo 09:00-17:00", "Tu 09:00-17:00", "We 09:00-17:00", "Th 09:00-17:00", "Fr 09:00-17:00"],
    "openStatus": "Geschlossen",
    "ratingValue": 5.0,
    "ratingCount": 1,
    "ratingSources": [
        { "source": "11880", "score": 5.0, "reviewCount": 1, "url": "https://www.11880.com/branchenbuch/berlin/..." }
    ],
    "hasRatings": true,
    "logoUrl": "https://ies.v4all.de/0122/TB/1126/1/8291/5178291_210x130.png",
    "detailUrl": "https://adresse.dastelefonbuch.de/Berlin/1-Hotels-Adlon-Holding-GmbH-Berlin-Friedrichstr.html",
    "searchType": "business",
    "searchQuery": "Hotel",
    "searchLocation": "Berlin",
    "scrapedAt": "2026-07-07T12:00:00.000Z"
}
````

### 📋 Dataset Views

The Apify Console gives you **2 ready-made table views** to quickly browse your results:

| View              | What It Shows                                                                      |
| ----------------- | ---------------------------------------------------------------------------------- |
| 📊 **Overview**   | Name, phone, address, category, email, website — the lead-generation essentials    |
| 📋 **All Fields** | Every single field — the complete dataset including ratings, hours and coordinates |

### ❓ FAQ

**🤔 Does it get the full phone number?**
Yes. Das Telefonbuch hides part of each number in the page to deter scrapers — this actor reconstructs the complete, dialable number every time.

**🤔 Are email addresses included?**
Yes, when you enable full details. The site obfuscates emails to hide them from bots; the actor decodes them back to plain text.

**🤔 What's the difference between the cheap and detailed modes?**
The default (cheap) mode returns name, full address, phone and category straight from the results page. Enable **Fetch Full Details** to also get email, website, fax, opening hours, GPS coordinates and ratings.

**🤔 Can I search all of Germany at once?**
Yes — leave the city empty for a nationwide business search. Note that Das Telefonbuch serves up to ~500 results per query, so for very large industries it's best to split by city or postcode.

**🤔 Can I export the data?**
Yes — JSON, CSV, Excel, XML, HTML, RSS. You can also push data directly to Google Sheets, Zapier, Make, or any webhook/API endpoint.

**🤔 How often should I run this?**
For fresh data, run daily or weekly. Turn on Incremental Monitoring to only pay for what changed, and schedule automatic runs on Apify with a few clicks.

**🤔 Does it work with proxies?**
It runs perfectly without any proxy. For very large or very fast runs you can optionally enable Apify's datacenter proxy.

### 🛠️ Need Custom Filters or Features?

**I'm happy to customize this scraper for your specific needs!** 🤝

Whether you need:

- 🎯 Additional filters (specific categories, postcode ranges, private-vs-business only, rating thresholds)
- 📊 Extra data fields or custom output formats
- 🔄 Integration with your CRM, Google Sheets, or database
- ⏰ Scheduled scraping with automatic deduplication
- 🌐 Scraping from other German directory platforms (Gelbe Seiten, Das Örtliche) alongside Das Telefonbuch

👉 **Don't hesitate to reach out via private message** — I respond quickly and I'm always open to building exactly what you need. No request is too small or too specific!

### ⚖️ Legal & Ethical Use

This scraper collects **only publicly available information** from Das Telefonbuch. It does not access private data, bypass authentication, or log in to any account. Please use the data responsibly and in compliance with applicable laws and platform terms of service.

# Actor input Schema

## `searchType` (type: `string`):

What to search: <b>Businesses</b> (Branchen — companies by keyword/category), <b>People</b> (Personen — private phone-book entries by last name) or <b>Reverse phone lookup</b> (Rückwärtssuche — find who owns a number).

## `searchQuery` (type: `string`):

Business keyword/category (e.g. <i>Friseur</i>, <i>Zahnarzt</i>, <i>Restaurant</i>), last name for people search (e.g. <i>Müller</i>), or the full phone number for reverse lookup (e.g. <i>030 8 52 19 63</i>).

## `location` (type: `string`):

German city or town, e.g. <i>Berlin</i>, <i>München</i>, <i>Hamburg</i>. Leave empty for a nationwide search (not used for reverse lookup).

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

Optional. Paste any telefonbuch.de / dastelefonbuch.de URLs — a search-results page (e.g. https://www.dastelefonbuch.de/Branchen/Friseur/Berlin) or an entry detail page (adresse.dastelefonbuch.de/…). Auto-classified. When provided, these REPLACE the search fields above.

## `includeDetails` (type: `boolean`):

When enabled, every entry's detail page is opened to collect email, website, fax, weekly opening hours, GPS coordinates and ratings (one extra request per entry). When disabled (default, cheapest), you still get the full listing card: name, complete address, FULL phone number and category.

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

Hard cap on the number of records pushed to the dataset. Use 0 for unlimited. Note: the site itself serves at most ~500 results (50 pages) per query — split by city district or postcode for more.

## `maxPages` (type: `integer`):

Maximum number of search-result pages to crawl (10 entries per page; the site clamps at 50 pages per query).

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests.

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried.

## `incremental` (type: `boolean`):

Track changes across runs. The first run records a baseline; later runs emit only NEW, UPDATED (e.g. changed phone/address) and REAPPEARED entries — typically 80–95% cheaper for recurring monitoring of the same search.

## `stateKey` (type: `string`):

Optional. Identifier for this monitoring baseline. Leave empty to derive one automatically from the search fields. Use a fixed value to keep one baseline across config tweaks.

## `emitUnchanged` (type: `boolean`):

Incremental only. Also output entries that did not change since the last run.

## `emitExpired` (type: `boolean`):

Incremental only. Also output entries that disappeared since the last run (e.g. business closed), tagged EXPIRED.

## `skipReposts` (type: `boolean`):

Incremental only. Drop NEW entries whose content matches a recently expired one (same entry re-listed under a new id).

## `proxyConfiguration` (type: `object`):

The site blocks unproxied cloud IPs, so the automatic Apify Proxy (datacenter, cheapest) is the default and works well. For very large or fast runs, switch to RESIDENTIAL with country DE.

## Actor input object example

```json
{
  "searchType": "business",
  "searchQuery": "Friseur",
  "location": "Berlin",
  "includeDetails": false,
  "maxResults": 100,
  "maxPages": 50,
  "maxConcurrency": 10,
  "maxRequestRetries": 5,
  "incremental": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "skipReposts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `detailed` (type: `string`):

No description

# 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 = {
    "searchQuery": "Friseur",
    "location": "Berlin",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/telefonbuch-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 = {
    "searchQuery": "Friseur",
    "location": "Berlin",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("trev0n/telefonbuch-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 '{
  "searchQuery": "Friseur",
  "location": "Berlin",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call trev0n/telefonbuch-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telefonbuch.de Scraper - German Directory & Phone Lookup",
        "description": "Scrape Das Telefonbuch (telefonbuch.de) — Germany's phone book. Search businesses by keyword & city, people by last name, or reverse phone lookup. Get full phone numbers, decoded emails, websites, opening hours, GPS and ratings. Incremental monitoring for cheap recurring runs.",
        "version": "1.0",
        "x-build-id": "lXTjhJeOeH6vMN55t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~telefonbuch-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-telefonbuch-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/trev0n~telefonbuch-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-telefonbuch-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/trev0n~telefonbuch-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-telefonbuch-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": {
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "business",
                            "person",
                            "reverse"
                        ],
                        "type": "string",
                        "description": "What to search: <b>Businesses</b> (Branchen — companies by keyword/category), <b>People</b> (Personen — private phone-book entries by last name) or <b>Reverse phone lookup</b> (Rückwärtssuche — find who owns a number).",
                        "default": "business"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Business keyword/category (e.g. <i>Friseur</i>, <i>Zahnarzt</i>, <i>Restaurant</i>), last name for people search (e.g. <i>Müller</i>), or the full phone number for reverse lookup (e.g. <i>030 8 52 19 63</i>)."
                    },
                    "location": {
                        "title": "Location (city)",
                        "type": "string",
                        "description": "German city or town, e.g. <i>Berlin</i>, <i>München</i>, <i>Hamburg</i>. Leave empty for a nationwide search (not used for reverse lookup)."
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced — overrides the search fields)",
                        "type": "array",
                        "description": "Optional. Paste any telefonbuch.de / dastelefonbuch.de URLs — a search-results page (e.g. https://www.dastelefonbuch.de/Branchen/Friseur/Berlin) or an entry detail page (adresse.dastelefonbuch.de/…). Auto-classified. When provided, these REPLACE the search fields above.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeDetails": {
                        "title": "Fetch full entry details",
                        "type": "boolean",
                        "description": "When enabled, every entry's detail page is opened to collect email, website, fax, weekly opening hours, GPS coordinates and ratings (one extra request per entry). When disabled (default, cheapest), you still get the full listing card: name, complete address, FULL phone number and category.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the number of records pushed to the dataset. Use 0 for unlimited. Note: the site itself serves at most ~500 results (50 pages) per query — split by city district or postcode for more.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of search-result pages to crawl (10 entries per page; the site clamps at 50 pages per query).",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of parallel requests.",
                        "default": 10
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many times a failed request is retried.",
                        "default": 5
                    },
                    "incremental": {
                        "title": "Incremental monitoring",
                        "type": "boolean",
                        "description": "Track changes across runs. The first run records a baseline; later runs emit only NEW, UPDATED (e.g. changed phone/address) and REAPPEARED entries — typically 80–95% cheaper for recurring monitoring of the same search.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "Monitoring state key",
                        "type": "string",
                        "description": "Optional. Identifier for this monitoring baseline. Leave empty to derive one automatically from the search fields. Use a fixed value to keep one baseline across config tweaks."
                    },
                    "emitUnchanged": {
                        "title": "Emit unchanged entries",
                        "type": "boolean",
                        "description": "Incremental only. Also output entries that did not change since the last run.",
                        "default": false
                    },
                    "emitExpired": {
                        "title": "Emit expired entries",
                        "type": "boolean",
                        "description": "Incremental only. Also output entries that disappeared since the last run (e.g. business closed), tagged EXPIRED.",
                        "default": false
                    },
                    "skipReposts": {
                        "title": "Skip reposts",
                        "type": "boolean",
                        "description": "Incremental only. Drop NEW entries whose content matches a recently expired one (same entry re-listed under a new id).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "The site blocks unproxied cloud IPs, so the automatic Apify Proxy (datacenter, cheapest) is the default and works well. For very large or fast runs, switch to RESIDENTIAL with country DE.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
