# Gelbe Seiten Scraper (`solidcode/gelbeseiten-scraper`) Actor

\[💰 $1.2 / 1K] Extract German business listings from Gelbe Seiten — name, address, phone, email, website, opening hours, categories, ratings, reviews, photos, and social links. Search by what + where, or paste Gelbe Seiten URLs directly.

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

## Pricing

from $1.20 / 1,000 businesses

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

## Gelbe Seiten Scraper

Extract every German business listing from [Gelbe Seiten](https://www.gelbeseiten.de) — Germany's national Yellow Pages — at scale. Pull names, full postal addresses, phone numbers, emails, websites, GPS coordinates, opening hours, services, photos, social links, ratings, and complete review feeds for any what-and-where search across all 16 federal states. Built for B2B sales teams, recruiters, and CRM enrichment pipelines that need verified German SMB contact data without stitching together regional directories themselves.

### Why This Scraper?

- **Two-tier pricing — pay only for what you collect.** $1.20 per 1,000 businesses + $0.30 per 1,000 reviews. Toggle reviews off and review charges disappear entirely.
- **Verified contact stack on every row** — phone, email, website, street address, postal code, city, district, and GPS latitude/longitude pulled from each business's detail page.
- **Full review history per business** — review text, 0–5 rating, author, date, helpful count, and original review-source attribution preserved (golocal partner network and others). Up to 5,000 reviews per business.
- **Three input modes in one run** — keyword + location ("Restaurant" + "Berlin"), direct search URLs (`/suche/restaurant/10115`), or specific business URLs (`/gsbiz/<ID>`). Mix and match freely.
- **All 16 German federal states + every Postleitzahl** — Berlin, München, Hamburg, Köln, Frankfurt, Stuttgart, and every 5-digit postal code in between. Search by city or PLZ.
- **Two sort modes** — relevance (Gelbe Seiten default) or `bewertung` (highest-rated first), so you can surface top-rated providers before paginating deep.
- **Lead-only mode for cheap directory pulls** — disable detail enrichment to pay only the business rate ($1.20 / 1,000) and skip the review event entirely. Ideal for fast prospect-list builds.
- **Fresh-review guarantee** — review records are only emitted when Gelbe Seiten's live review module confirms the listing is active. Stale federation reviews on inactive listings are dropped automatically; you never pay for ghost data.
- **Stable, schema-aware extraction** — every business is keyed by Gelbe Seiten's canonical UUID (`gelbeseitenId`) so you can dedupe across runs even when names or branding change.

### Use Cases

**Lead Generation & B2B Sales**
- Build prospect lists of every Steuerberater, Klempner, or Friseur in a target city
- Pull verified phone + email + website for every SMB in a Postleitzahl-bound territory
- Layer queries (e.g. "Restaurant" in 25 cities) into one run for nation-wide outreach lists

**Market Research & Competitive Intelligence**
- Map competitor density by federal state, city, or district (`Bezirk`)
- Compare review volume and average ratings across regional sub-markets
- Snapshot a category monthly to track new entrants and closures

**CRM Enrichment & Data Cleansing**
- Match existing German account rows against Gelbe Seiten by name + city to backfill phone, email, website, and GPS
- Pull `services` and `categories` arrays to enrich industry tagging
- Refresh stale contact details for an existing book of business

**Recruiting & Talent Sourcing**
- Source German SMB hiring managers from Gelbe Seiten's category browser
- Pair with social-link extraction to surface LinkedIn, Facebook, and Instagram presence per company

**Local-SEO Audits & Listings Management**
- Audit a client's Gelbe Seiten profile against competitors in the same district
- Pull every review on a competitor's listing — full text, dates, owner replies — for sentiment and recurring-complaint analysis
- Validate citation consistency (NAP) across regional rivals

**Data Journalism & Academic Research**
- Build longitudinal datasets of German local-business density
- Aggregate ratings and review counts by region for economic analysis
- Power studies on regional service availability (healthcare, legal, automotive)

### Getting Started

#### Simple — Keyword + City

The fastest path: enter what you want and where in Germany.

```json
{
    "searchQueries": ["Restaurant"],
    "location": "Berlin",
    "maxResults": 50
}
````

#### Highest-Rated First

Sort by rating to surface the top providers before deep pagination kicks in.

```json
{
    "searchQueries": ["Klempner"],
    "location": "München",
    "sort": "bewertung",
    "maxResults": 100
}
```

#### Direct URL — Postal-Code Targeting

Paste a Gelbe Seiten URL and the actor honors every filter in it (sort, radius, postcode).

```json
{
    "searchUrls": [
        "https://www.gelbeseiten.de/suche/restaurant/10115",
        "https://www.gelbeseiten.de/branchen/restaurant/berlin"
    ],
    "maxResults": 200
}
```

#### Lead-Only Power Run

Disable review enrichment for the cheapest, fastest possible run — names, addresses, phones, ratings, and primary categories only. Pay $1.20 per 1,000 businesses, no review charges at all.

```json
{
    "searchQueries": ["Steuerberater", "Rechtsanwalt", "Notar"],
    "location": "Hamburg",
    "includeReviews": false,
    "maxResults": 1000
}
```

#### Mixed Run — Queries + URLs + Cap

Combine multiple search terms, a direct business URL, and a high review cap.

```json
{
    "searchQueries": ["Friseur"],
    "location": "Köln",
    "searchUrls": [
        "https://www.gelbeseiten.de/gsbiz/00000000-0000-0000-0000-000000000000"
    ],
    "includeReviews": true,
    "maxReviewsPerBusiness": 100,
    "maxResults": 500
}
```

### Input Reference

#### Search Inputs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["Restaurant"]` | What to search for on Gelbe Seiten (e.g. `Restaurant`, `Klempner`, `Steuerberater`, `Friseur`). One row per term. |
| `location` | string | `"Berlin"` | Where to search in Germany. City name (e.g. `Berlin`, `München`, `Hamburg`) or 5-digit postal code (e.g. `10115`). Leave empty if your queries already include a location, or if you're using direct URLs. |
| `searchUrls` | string\[] | `[]` | Paste Gelbe Seiten URLs directly: search results, category pages, or individual business pages. Filters in the URL (sort, radius, postcode) are honored as-is. |

#### Filtering

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sort` | select | `Relevance (default)` | Order of results — `Relevance (default)` or `Highest Rated First`. Rating sort surfaces the top-rated providers from row 1. |

#### Output Detail

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReviews` | boolean | `true` | Visit each business's detail page to collect reviews, photos, social links, full opening hours, and services. Disable for faster, cheaper runs that return only search-card data (name, address, phone, rating, primary category). |
| `maxReviewsPerBusiness` | integer | `20` | Cap on reviews captured per business (most recent first). Set to `0` to capture every available review. Ignored when `Include Detailed Profile Data` is off. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Hard cap on total business rows across all queries and URLs. Set to `0` for no cap. The run stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. |

### Output

Each result is one **business row** — a German listing with all profile fields and (when enabled) an embedded `reviews[]` array. Example:

```json
{
    "name": "Bass Gastro UG",
    "url": "https://www.gelbeseiten.de/gsbiz/00000000-0000-0000-0000-000000000000",
    "gelbeseitenId": "00000000-0000-0000-0000-000000000000",
    "categories": ["Restaurants", "Italienisches Restaurant"],
    "description": "Familiengeführtes italienisches Restaurant im Herzen von Köpenick...",
    "phone": "+49 30 12345678",
    "email": "info@example.de",
    "website": "https://www.example.de",
    "street": "Beispielstraße 12",
    "postalCode": "12555",
    "city": "Berlin",
    "district": "Köpenick",
    "country": "DE",
    "latitude": 52.4561,
    "longitude": 13.5712,
    "rating": 5.0,
    "ratingCount": 2,
    "openingHours": [
        { "day": "Monday", "open": "11:30", "close": "22:00" },
        { "day": "Tuesday", "open": "11:30", "close": "22:00" }
    ],
    "services": ["Lieferung", "Außerhausverkauf"],
    "socialLinks": {
        "facebook": "https://www.facebook.com/bassgastro",
        "instagram": "https://www.instagram.com/bassgastro",
        "twitter": null,
        "linkedin": null,
        "youtube": null
    },
    "images": [
        "https://example-cdn.de/photo1.jpg",
        "https://example-cdn.de/photo2.jpg"
    ],
    "reviews": [
        {
            "author": "Paula Beck",
            "rating": 5.0,
            "date": "2023-01-20",
            "title": "Sehr empfehlenswert",
            "body": "Tolles Essen, freundlicher Service, schöne Atmosphäre.",
            "helpfulCount": 3,
            "ownerReply": null,
            "source": "golocal",
            "sourceUrl": "https://www.golocal.de/...",
            "reviewId": "12345678"
        }
    ],
    "searchQuery": "Restaurant",
    "searchLocation": "Berlin",
    "scrapedAt": "2026-05-08T14:30:00Z"
}
```

#### Core Identity

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name |
| `url` | string | Canonical Gelbe Seiten detail URL |
| `gelbeseitenId` | string | Internal Gelbe Seiten UUID — stable across runs, ideal for deduping |
| `categories` | string\[] | All Gelbe Seiten categories for this business |
| `description` | string | null | Short business description / tagline |

#### Contact

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | null | Primary phone number |
| `email` | string | null | Primary email address |
| `website` | string | null | Business website (Gelbe Seiten / partner / federation links filtered out) |

#### Address & Geo

| Field | Type | Description |
|-------|------|-------------|
| `street` | string | null | Street and house number |
| `postalCode` | string | null | German postal code (PLZ) |
| `city` | string | null | City |
| `district` | string | null | District / borough — e.g. `Mitte`, `Köpenick` |
| `country` | string | Always `"DE"` |
| `latitude` | number | null | GPS latitude |
| `longitude` | number | null | GPS longitude |

#### Ratings & Hours

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | null | Average star rating (0–5) |
| `ratingCount` | integer | null | Total number of ratings |
| `openingHours` | object\[] | Per-weekday open / close pairs: `{day, open, close}` in English day names + 24-hour times |
| `services` | string\[] | Services published on the detail page (e.g. `["Lieferung", "Außerhausverkauf"]`) |

#### Media & Social

| Field | Type | Description |
|-------|------|-------------|
| `socialLinks` | object | `{facebook, instagram, twitter, linkedin, youtube}` — each is a URL or `null` |
| `images` | string\[] | Photo URLs from the gallery + cover image |

#### Run Metadata

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | null | The search term that produced this row |
| `searchLocation` | string | null | The location used for that search |
| `scrapedAt` | string | ISO-8601 timestamp when the row was captured |

#### Review Fields (when `includeReviews=true`)

Each entry inside the `reviews[]` array:

| Field | Type | Description |
|-------|------|-------------|
| `author` | string | null | Reviewer display name (or `null` for anonymous) |
| `rating` | number | null | Reviewer's star rating (0–5) |
| `date` | string | null | Review date in ISO format (`YYYY-MM-DD`) |
| `title` | string | null | Review title, when present |
| `body` | string | null | Full review text |
| `helpfulCount` | integer | null | Number of "helpful" upvotes |
| `ownerReply` | string | null | Business owner's reply, when posted |
| `source` | string | null | Original review source (`golocal`, partner network name, or `gelbeseiten`) |
| `sourceUrl` | string | null | Link to the original review on the source platform, when available |
| `reviewId` | string | null | Stable review identifier for downstream dedupe |

### Tips for Best Results

- **Use specific German trade terms.** `Steuerberater`, `Heizungsbau`, `Fliesenleger`, `Optiker` return tighter, more relevant pools than English equivalents. Gelbe Seiten is a German-language directory.
- **Postal codes beat city names for precision.** Searching `10115` returns Berlin-Mitte only; searching `Berlin` covers all 12 boroughs. PLZ is the cleanest territorial filter.
- **Lead-only mode for prospect-list speed.** Set `includeReviews=false` when you only need names, addresses, phones, and primary categories. The run skips per-business detail pages, finishes much faster, and pays only the business rate.
- **Bulk vertical pulls via `searchUrls`.** Paste category URLs like `https://www.gelbeseiten.de/branchen/restaurant/berlin` into `searchUrls` to bypass keyword tuning. The actor automatically rewrites `/branchen/...` to `/suche/...` so pagination unlocks the full result pool instead of capping at 10.
- **Sort by rating for "best of" lists.** When you only need the highest-rated providers in a category, sort by `Highest Rated First` and lower `maxResults` — you'll skip the long tail entirely.
- **Cap reviews to control cost.** Default `maxReviewsPerBusiness=20` captures the most recent 20 reviews per listing. Set to `0` for the full history, or to a smaller number like `5` for sentiment-only sampling.
- **Dedupe across runs by `gelbeseitenId`.** The UUID is stable — overlapping runs or weekly refreshes can be merged on this field without name-matching drift.
- **A small share of listings have inactive review feeds.** Some Gelbe Seiten profiles display a public review count but the underlying review feed is no longer active — those businesses ship with `reviews: []` and are not charged at the review rate. Your dataset stays clean and you only pay for reviews you actually receive.

### Pricing

**$1.20 per 1,000 businesses + $0.30 per 1,000 reviews — pay-per-event. No compute charges, no run-time surprises.**

You're billed for two things only:

- **Business row** — $1.20 per 1,000 businesses returned ($0.0012 each).
- **Review** — $0.30 per 1,000 reviews captured ($0.00030 each), only when `Include Detailed Profile Data` is on. Turn it off and review charges disappear — you pay only for business rows.

| Businesses | Lead-only (reviews off) | With ~10 reviews per business |
|------------|-------------------------|-------------------------------|
| 100 | $0.12 | $0.42 |
| 1,000 | $1.20 | $4.20 |
| 10,000 | $12.00 | $42.00 |
| 100,000 | $120.00 | $420.00 |

If a run hits an error and returns zero rows, you pay nothing.

### Integrations

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

- **Apify API** — Full programmatic access to runs, datasets, and schedules
- **Webhooks** — Trigger downstream workflows when a run completes
- **Google Sheets** — Direct spreadsheet export
- **Zapier / Make / n8n** — Automate workflows with 1,000+ app integrations
- **Slack / Email** — Notifications on new results
- **Datasets** — Download as JSON, CSV, XML, or Excel

### Legal & Ethical Use

This actor extracts publicly visible business listings from Gelbe Seiten for legitimate B2B research, lead generation, market intelligence, and CRM enrichment. Only public business data is collected — no personal user information, no private accounts, no information behind authentication. Users are responsible for complying with applicable laws, Gelbe Seiten's Terms of Service, and German / EU data-protection regulations (GDPR, BDSG) in their jurisdiction. Do not use the extracted data for spam, harassment, or any illegal purpose. When publishing or redistributing review content, attribute Gelbe Seiten and the original review source.

# Actor input Schema

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

What to search for on Gelbe Seiten (e.g. 'Restaurant', 'Klempner', 'Steuerberater', 'Friseur'). One row per search term. Leave empty if you're using direct URLs below.

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

Where to search in Germany. City name (e.g. 'Berlin', 'München', 'Hamburg') or postal code (e.g. '10115'). Leave empty if your search queries already include a location, or if you're using direct URLs.

## `searchUrls` (type: `array`):

Paste Gelbe Seiten URLs directly: search results (e.g. https://www.gelbeseiten.de/suche/restaurant/berlin), category pages (e.g. https://www.gelbeseiten.de/branchen/restaurant), or individual business pages. Filters in the URL (sort, radius, postcode) are honored as-is.

## `sort` (type: `string`):

Order of results. Relevance is the Gelbe Seiten default; rating sorts the highest-rated businesses first.

## `includeReviews` (type: `boolean`):

Visit each business's detail page to collect reviews, photos, social links, full opening hours, and services. Disable for faster, cheaper runs that return only the search-card data (name, address, phone, rating, primary category).

## `maxReviewsPerBusiness` (type: `integer`):

Cap on the number of reviews captured per business (most recent first). Set to 0 to capture every available review (capped internally at 5,000 per business to prevent runaway pagination). Ignored when 'Include Detailed Profile Data' is off.

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

Hard cap on total business rows across all queries and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 10,000 still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

```json
{
  "searchQueries": [
    "Restaurant"
  ],
  "location": "Berlin",
  "searchUrls": [],
  "sort": "relevanz",
  "includeReviews": true,
  "maxReviewsPerBusiness": 20,
  "maxResults": 100
}
```

# Actor output Schema

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

Quick view of extracted businesses with key contact and rating fields.

## `detail` (type: `string`):

Full payload per business including reviews, opening hours, photos, and social links.

# 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": [
        "Restaurant"
    ],
    "location": "Berlin",
    "searchUrls": [],
    "sort": "relevanz",
    "includeReviews": true,
    "maxReviewsPerBusiness": 20,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/gelbeseiten-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": ["Restaurant"],
    "location": "Berlin",
    "searchUrls": [],
    "sort": "relevanz",
    "includeReviews": True,
    "maxReviewsPerBusiness": 20,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/gelbeseiten-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": [
    "Restaurant"
  ],
  "location": "Berlin",
  "searchUrls": [],
  "sort": "relevanz",
  "includeReviews": true,
  "maxReviewsPerBusiness": 20,
  "maxResults": 100
}' |
apify call solidcode/gelbeseiten-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gelbe Seiten Scraper",
        "description": "[💰 $1.2 / 1K] Extract German business listings from Gelbe Seiten — name, address, phone, email, website, opening hours, categories, ratings, reviews, photos, and social links. Search by what + where, or paste Gelbe Seiten URLs directly.",
        "version": "1.0",
        "x-build-id": "2OIFr8kn5IEDPJuUy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~gelbeseiten-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-gelbeseiten-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~gelbeseiten-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-gelbeseiten-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~gelbeseiten-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-gelbeseiten-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 Queries",
                        "type": "array",
                        "description": "What to search for on Gelbe Seiten (e.g. 'Restaurant', 'Klempner', 'Steuerberater', 'Friseur'). One row per search term. Leave empty if you're using direct URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search in Germany. City name (e.g. 'Berlin', 'München', 'Hamburg') or postal code (e.g. '10115'). Leave empty if your search queries already include a location, or if you're using direct URLs."
                    },
                    "searchUrls": {
                        "title": "Gelbe Seiten URLs",
                        "type": "array",
                        "description": "Paste Gelbe Seiten URLs directly: search results (e.g. https://www.gelbeseiten.de/suche/restaurant/berlin), category pages (e.g. https://www.gelbeseiten.de/branchen/restaurant), or individual business pages. Filters in the URL (sort, radius, postcode) are honored as-is.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "relevanz",
                            "bewertung"
                        ],
                        "type": "string",
                        "description": "Order of results. Relevance is the Gelbe Seiten default; rating sorts the highest-rated businesses first.",
                        "default": "relevanz"
                    },
                    "includeReviews": {
                        "title": "Include Detailed Profile Data",
                        "type": "boolean",
                        "description": "Visit each business's detail page to collect reviews, photos, social links, full opening hours, and services. Disable for faster, cheaper runs that return only the search-card data (name, address, phone, rating, primary category).",
                        "default": true
                    },
                    "maxReviewsPerBusiness": {
                        "title": "Max Reviews per Business",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on the number of reviews captured per business (most recent first). Set to 0 to capture every available review (capped internally at 5,000 per business to prevent runaway pagination). Ignored when 'Include Detailed Profile Data' is off.",
                        "default": 20
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total business rows across all queries and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 10,000 still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```