# GelbeSeiten Leads Scraper (Cheap) (`data_api/gelbeseiten-leads-scraper-cheap`) Actor

GelbeSeiten Lead Extractor pulls business contacts from Germany's online business directory, so sales teams and marketers can build prospect lists for any city and industry without manual searching.

- **URL**: https://apify.com/data\_api/gelbeseiten-leads-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (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 $3.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## GelbeSeiten Leads Scraper

![GelbeSeiten Leads Scraper](cover.jpg)

Building a contact list off GelbeSeiten by hand means opening each result, copying the phone number, the address, the website, and pasting it all into a sheet one business at a time. This scraper skips that. Give it a German keyword and a city, and every matching business comes back as a clean row with the company name, phone, address, website, and rating already split into fields. It runs on the GelbeSeiten directory, it's cheap, it needs no code, and you only pay for the rows you pull.

### What you get

Each business listing comes back as one row, grouped into three kinds of data:

- **Who and where** — `companyName`, `sectorName`, `streetAddress`, `postCode`, `cityName`, `fullAddress`
- **How to reach them** — `phoneNumber`, `websiteUrl`, `listingUrl`, `businessHours`
- **Reputation and context** — `starRating`, `reviewsTotal`, `profileSummary`, `searchPageUrl`, `searchTerm`, `searchCity`

### Quick start

1. Add one or more German keywords to **Search terms** (for example `zahnarzt` or `friseur`).
2. Add the cities you want covered to **Cities** (for example `köln`, `dresden`).
3. Set a **Results limit** to cap how many listings come back per keyword-and-city pair.
4. Press **Start**, then export the rows as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

### Use cases

- **Sales prospecting** — pull targeted lead lists for any German city and trade
- **Cold outreach** — gather phone numbers and websites for campaigns
- **Competitor mapping** — list every business in a category across several cities
- **Market sizing** — compare business counts, ratings, and coverage by region
- **CRM enrichment** — bulk-load German business contacts into your pipeline
- **Local SEO work** — collect category, address, and rating data to analyse

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | Yes | German keywords to look up; each one is run against every city. Prefilled with `zahnarzt`. |
| `searchCities` | array of strings | Yes | German cities, districts, or regions; each is paired with every keyword. Prefilled with `köln`. |
| `resultsLimit` | integer | No | Most listings to gather per keyword-and-city pair. Pagination runs until the cap is hit. Default `75`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each page request before giving up. Default `45`. |

#### Example input

```json
{
    "searchTerms": ["friseur", "baeckerei", "steuerberater"],
    "searchCities": ["köln", "dresden", "stuttgart"],
    "resultsLimit": 75,
    "timeoutSeconds": 45
}
````

This runs 9 searches (3 terms × 3 cities) and returns up to 675 rows.

### Output

Every business on the results page becomes one row, paginated automatically until your limit is reached. Fields that GelbeSeiten does not show for a given business come back as `null` rather than guessed.

#### Example output

```json
{
    "companyName": "Friseur Schöneberg",
    "sectorName": "Friseure",
    "streetAddress": "Hauptstr. 24",
    "postCode": "50667",
    "cityName": "Köln",
    "fullAddress": "Hauptstr. 24, 50667 Köln",
    "phoneNumber": "0221 25 76 25 96",
    "websiteUrl": "https://friseur-schoeneberg.de/",
    "starRating": 4.7,
    "reviewsTotal": 38,
    "profileSummary": "Moderner Friseursalon im Herzen von Köln.",
    "businessHours": "Geöffnet – Schließt um 18:00",
    "listingUrl": "https://www.gelbeseiten.de/gsbiz/45c22f1a-3b99-4c04-9f0e-534ca0cd64d8",
    "searchPageUrl": "https://www.gelbeseiten.de/suche/friseur/koeln",
    "searchTerm": "friseur",
    "searchCity": "köln"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `companyName` | string | Trading name of the business |
| `sectorName` | string | Industry or trade category |
| `streetAddress` | string | Street name and house number |
| `postCode` | string | Five-digit German postal code |
| `cityName` | string | Town or district |
| `fullAddress` | string | Complete address as printed on the listing |
| `phoneNumber` | string | Main contact line |
| `websiteUrl` | string | Link to the company website |
| `starRating` | number | Average customer score out of 5.0 |
| `reviewsTotal` | integer | Number of customer reviews |
| `profileSummary` | string | Short blurb or tagline from the listing |
| `businessHours` | string | Open or closed status with next closing time |
| `listingUrl` | string | Direct link to the GelbeSeiten profile |
| `searchPageUrl` | string | Results page the listing came from |
| `searchTerm` | string | Keyword that surfaced the listing |
| `searchCity` | string | City that was searched |

### Tips for best results

- **Keep keywords in German.** GelbeSeiten is a German directory, so `arzt` and `bäckerei` return results where their English equivalents will not.
- **List many cities at once.** Put every city in `searchCities` instead of running the actor again per city; each one pairs with each keyword automatically.
- **Use `resultsLimit` for test runs.** Start at 25 to confirm the columns fit your sheet, then raise it for the full pull.
- **The limit is per pair, not per run.** With 3 keywords and 4 cities at a limit of 50, you can get up to 600 rows, so set it with the total in mind.
- **Raise `timeoutSeconds`** if large result sets start timing out.
- Ratings show in German comma format on the site and are converted to standard decimals in the output.

### How can I use GelbeSeiten business data?

**How can I use the GelbeSeiten Leads Scraper to build a German sales list?**
Add the trades you sell to in `searchTerms` and your target cities in `searchCities`. Each row carries `companyName`, `phoneNumber`, `websiteUrl`, and `fullAddress`, so the export drops straight into a CRM or a dialer with no clean-up.

**How can I find all businesses in one category across German cities?**
Put a single keyword such as `rechtsanwalt` in `searchTerms` and list every city you care about in `searchCities`. The actor pairs the keyword with each city and returns `companyName`, `sectorName`, `cityName`, and `listingUrl` for the whole set.

**How can I collect German business contact data for market research?**
Set `resultsLimit` to the volume you need and export to CSV or Excel. With `starRating`, `reviewsTotal`, `sectorName`, and `cityName` on every row, you can measure business density and reputation by region.

**How can I scrape phone numbers and websites from GelbeSeiten?**
Run any keyword-and-city combination and read the `phoneNumber` and `websiteUrl` fields. Both are pulled per listing, and rows where the business hides one of them still carry everything else.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

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

German keywords to look up, for example friseur, steuerberater, baeckerei. Every term runs against every city you list.

## `searchCities` (type: `array`):

German cities, districts, or regions to search, for example köln, dresden, stuttgart. Each city is combined with every keyword.

## `resultsLimit` (type: `integer`):

Most listings to gather for one keyword-and-city pair. With 2 terms and 3 cities you can land up to 6 times this number of rows.

## `timeoutSeconds` (type: `integer`):

How long to wait on each page request before giving up.

## Actor input object example

```json
{
  "searchTerms": [
    "friseur",
    "baeckerei",
    "steuerberater"
  ],
  "searchCities": [
    "köln",
    "dresden",
    "stuttgart"
  ],
  "resultsLimit": 50,
  "timeoutSeconds": 45
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "zahnarzt"
    ],
    "searchCities": [
        "köln"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/gelbeseiten-leads-scraper-cheap").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": ["zahnarzt"],
    "searchCities": ["köln"],
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/gelbeseiten-leads-scraper-cheap").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "zahnarzt"
  ],
  "searchCities": [
    "köln"
  ]
}' |
apify call data_api/gelbeseiten-leads-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GelbeSeiten Leads Scraper (Cheap)",
        "description": "GelbeSeiten Lead Extractor pulls business contacts from Germany's online business directory, so sales teams and marketers can build prospect lists for any city and industry without manual searching.",
        "version": "0.0",
        "x-build-id": "1WwV4Qfn4d4MGH3Qb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~gelbeseiten-leads-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-gelbeseiten-leads-scraper-cheap",
                "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/data_api~gelbeseiten-leads-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-gelbeseiten-leads-scraper-cheap",
                "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/data_api~gelbeseiten-leads-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-gelbeseiten-leads-scraper-cheap",
                "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": [
                    "searchTerms",
                    "searchCities"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "German keywords to look up, for example friseur, steuerberater, baeckerei. Every term runs against every city you list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchCities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "German cities, districts, or regions to search, for example köln, dresden, stuttgart. Each city is combined with every keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Results limit",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Most listings to gather for one keyword-and-city pair. With 2 terms and 3 cities you can land up to 6 times this number of rows.",
                        "default": 50
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each page request before giving up.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
