# Gelbe Seiten Leads Scraper (`kinaesthetic_millionaire/gelbeseiten-leads-scraper`) Actor

Extract structured business information from gelbeseiten.de(the German Yellow Pages) such as contact details, categories, ratings and geo coordinates.

- **URL**: https://apify.com/kinaesthetic\_millionaire/gelbeseiten-leads-scraper.md
- **Developed by:** [Parsedom Inc](https://apify.com/kinaesthetic_millionaire) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

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 Leads Scraper

This Apify actor extracts business listings from [Gelbe Seiten](https://www.gelbeseiten.de) (the German Yellow Pages). It navigates through search result pages, collects all detail page URLs, and then extracts structured business information including contact details, categories, ratings, and geo‑coordinates.

### What does Gelbe Seiten Leads Scraper do?

**Gelbe Seiten Leads Scraper** lets you extract structured business data from [gelbeseiten.de](https://www.gelbeseiten.de) at scale — no coding required. Simply provide one or more search result URLs (e.g. `https://www.gelbeseiten.de/suche/restaurants/berlin`) and the actor will automatically paginate through all results, visit each business profile, and return clean, structured data ready for export or integration.

All extracted data is available via the Apify API, can be scheduled to run on a recurring basis, integrated with thousands of tools via webhooks or Zapier, and exported in JSON, CSV, or Excel — all from the Apify platform.

### Why use Gelbe Seiten Leads Scraper?

- **Lead generation** — Build targeted B2B lead lists by industry and region. Extract business names, phone numbers, websites, and addresses in bulk.
- **Market research** — Analyse business density, categories, and ratings across German cities and regions.
- **CRM enrichment** — Verify and enrich existing contact records with up-to-date addresses, phones, and websites from Gelbe Seiten.
- **Competitor analysis** — Map competitors in a specific niche and location by scraping category pages.
- **Directory aggregation** — Combine Gelbe Seiten data with other sources to build comprehensive local business databases.
- **Academic and journalism research** — Study the distribution of businesses across German regions.

### How to use Gelbe Seiten Leads Scraper

1. Go to [Gelbe Seiten](https://www.gelbeseiten.de) and run a search (e.g. "Restaurants in Berlin").
2. Copy the URL of the search results page.
3. Open this actor in the **Apify Console** and click **Try for free**.
4. Paste the URL(s) into the **Start URLs** field.
5. Optionally set **Max Results** to cap the number of businesses extracted.
6. Click **Start** and wait for the run to finish.
7. Download your data in JSON, CSV, or Excel from the **Output** tab.

### Input

The actor accepts a JSON object. You must provide at least one start URL.

| Field                | Type                        | Description                                                                                                                                                                                                               |
| -------------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `startUrls`          | Array of strings or objects | The initial Gelbe Seiten search result pages (listing pages) to begin scraping. Each entry can be a simple string URL or an object with a `url` property. Example: `"https://www.gelbeseiten.de/suche/schulen/wuppertal"` |
| `maxResults`         | Number (optional)           | Maximum number of business detail pages to extract. If omitted or set to `null`, the actor will scrape all available results.                                                                                             |
| `proxyConfiguration` | Object (optional)           | Proxy settings for large scraping jobs. See the **Proxy** section below.                                                                                                                                                  |

#### Example Input

```json
{
    "startUrls": [
        "https://www.gelbeseiten.de/suche/schulen/wuppertal",
        "https://www.gelbeseiten.de/suche/restaurants/berlin"
    ],
    "maxResults": 200
}
````

### Output

The actor produces a dataset where each item represents one business. The **Overview** tab shows the key fields (URL, name, address, phone, website). Click **All fields** in the Output tab to view the full record including categories, coordinates, rating, rating count, and last updated date.

#### Output Fields

| Field         | Type             | Description                                                                      |
| ------------- | ---------------- | -------------------------------------------------------------------------------- |
| `url`         | string           | The full URL of the business detail page                                         |
| `id`          | string           | Internal Gelbe Seiten ID (`data-teilnehmerid`)                                   |
| `name`        | string           | Business name                                                                    |
| `address`     | string           | Full street address (street + number, postal code, city)                         |
| `phone`       | string           | Phone number (as shown on the page)                                              |
| `website`     | string           | Official website URL (`null` if not listed)                                      |
| `categories`  | array of strings | Business categories (e.g. `["Schulen", "Berufsbildende Schulen"]`)               |
| `coordinates` | object           | Latitude and longitude (`null` if unavailable) – `{ lat, lng }`                  |
| `rating`      | number           | Average star rating (e.g. `4.5`; `null` if no reviews)                           |
| `ratingCount` | number           | Number of reviews (`null` if no reviews)                                         |
| `lastUpdated` | string           | ISO date when the business information was last modified (`null` if unavailable) |

> Fields unavailable on a page are included with a `null` value so every record has a consistent structure.

#### Example Output (JSON)

```json
{
    "url": "https://www.gelbeseiten.de/gsbiz/6a2b5da6-cf68-4fe3-bc3d-6fab868a7dab",
    "id": "161096212181",
    "name": "Cosmetic College Bochum Inh. Claudia Bryjak",
    "address": "Gerberstr. 18-20, 44787 Bochum-Innenstadt",
    "phone": "0234 5 86 26 28",
    "website": "https://cosmetic-college-bochum-und-institut.de/",
    "categories": ["BERUFSBILDENDE SCHULEN"],
    "coordinates": {
        "lat": 51.483383,
        "lng": 7.2195573
    },
    "rating": "4.9",
    "ratingCount": 19,
    "lastUpdated": "2026-05-04"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from the **Output** tab after the run completes.

### Proxy configuration

For large scraping jobs (hundreds or thousands of businesses), using a proxy is strongly recommended. Gelbe Seiten may rate-limit or block repeated requests from a single IP address.

#### Recommended setup

Enable **Apify Proxy** in the actor's Input tab under **Proxy configuration**:

```json
{
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

- **Datacenter proxies** — Suitable for moderate-scale runs (up to a few hundred pages). Faster and cheaper, but more likely to be blocked on aggressive scraping.
- **Residential proxies** — Best for large-scale runs or when datacenter proxies get blocked. Rotate through real residential IPs to stay under the radar.

#### Tips for large runs

- Set `maxConcurrency` lower (e.g. 3–5) when using residential proxies to avoid burning through proxy quota.
- Add a short delay between requests if you notice failures — the actor uses Playwright which already respects Apify's built-in retry and backoff strategies.
- Split very large searches (e.g. all of Germany for a broad category) into smaller regional runs to distribute load.

### Tips and advanced options

- **Pagination is automatic** — The actor follows "next page" links on listing pages, so you do not need to provide paginated URLs manually.
- **Cap results with `maxResults`** — Set this to a small number (e.g. `10`) during testing to avoid burning compute units while you verify the output format.
- **Multiple start URLs** — Pass multiple search result URLs (different categories or cities) in one run to combine them into a single dataset.
- **Scheduling** — Use Apify's built-in scheduler to refresh your dataset weekly or monthly.

### FAQ and disclaimers

**Is scraping Gelbe Seiten legal?**
This actor collects publicly available business information. It is your responsibility to ensure your use of the data complies with Gelbe Seiten's Terms of Service, applicable data protection laws (including GDPR), and your local regulations. Do not use this tool to collect personal data for unsolicited marketing without a lawful basis.

**Some fields are missing from the output — why?**
Not all business profiles on Gelbe Seiten have complete information. Fields like `rating`, `ratingCount`, `website`, and `coordinates` are only available when the business has provided them. Missing fields appear as `null` in the output.

**The run seems slow — how can I speed it up?**
The actor uses a browser-based crawler (Playwright) because Gelbe Seiten renders content dynamically. Browser crawlers are inherently slower than HTTP-only crawlers. Increasing concurrency slightly (up to 3–5) can help, but going higher risks rate limiting.

### More leads scrapers by Parsedom

Looking for leads from other platforms? Check out our other scrapers:

| Actor                                                                                   | Description                                                                         |
| --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| [Hipages Lead Scraper](https://apify.com/kinaesthetic_millionaire/hipages-lead-scraper) | Extract business leads from Hipages, Australia's leading trade services directory   |
| [Branchenbuch Leads Scraper](https://apify.com/kinaesthetic_millionaire/branchenbuch)   | Scrape business listings from Branchenbuch, another major German business directory |
| [Booksy Leads Scraper](https://apify.com/kinaesthetic_millionaire/booksy-leads-scraper) | Extract salon, spa, and beauty business leads from Booksy                           |

### Custom actor development

Need a scraper for a platform not listed above? **We build custom Apify actors tailored to your specific requirements** — any website, any data structure, any scale.

Whether you need a one-off extraction or a fully automated recurring pipeline, we can design and deliver a production-ready actor for you. [Get in touch](#-support) to discuss your project.

### 🤝 Support

Need help or have questions?

- 📧 Email us at <info@parsedom.com>
- 🌐 Visit us at [parsedom.com](https://parsedom.com)
- 💼 Find us on Fiverr: [fiverr.com/s/rEmNqEb](https://www.fiverr.com/s/rEmNqEb)
- 🤖 Apify expert page: https://apify.com/partners/find/parsedom-inc

You can also contact us if you want to build a custom actor.

***

Ready to generate quality leads from Gelbe Seiten? Add your target URLs and start scraping! 🚀

# Actor input Schema

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

One or more search result (listing) URLs from Gelbe Seiten

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

Maximum number of business detail pages to extract. Leave empty for no limit.

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

Proxy settings for the crawler. Residential proxies are recommended to avoid blocking.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.gelbeseiten.de/suche/schulen/wuppertal"
  ],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        "https://www.gelbeseiten.de/suche/schulen/wuppertal"
    ],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kinaesthetic_millionaire/gelbeseiten-leads-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 = {
    "startUrls": ["https://www.gelbeseiten.de/suche/schulen/wuppertal"],
    "maxResults": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kinaesthetic_millionaire/gelbeseiten-leads-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 '{
  "startUrls": [
    "https://www.gelbeseiten.de/suche/schulen/wuppertal"
  ],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kinaesthetic_millionaire/gelbeseiten-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gelbe Seiten Leads Scraper",
        "description": "Extract structured business information from gelbeseiten.de(the German Yellow Pages) such as contact details, categories, ratings and geo coordinates.",
        "version": "1.0",
        "x-build-id": "wMmBQgK2BSZTVjCIV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kinaesthetic_millionaire~gelbeseiten-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kinaesthetic_millionaire-gelbeseiten-leads-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/kinaesthetic_millionaire~gelbeseiten-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kinaesthetic_millionaire-gelbeseiten-leads-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/kinaesthetic_millionaire~gelbeseiten-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kinaesthetic_millionaire-gelbeseiten-leads-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more search result (listing) URLs from Gelbe Seiten",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of business detail pages to extract. Leave empty for no limit.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the crawler. Residential proxies are recommended to avoid blocking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
