# Gelbe Seiten Scraper 🇩🇪 (German B2B leads: phone & email) (`tagadanar/gelbeseiten-scraper`) Actor

Turn a Gelbeseiten search into a clean B2B lead list. Give a business term (Was) and a German location (Wo); get each business with name, address, phone, email, website and category. Phone and email are pulled from the business page. Pay per result, no subscription.

- **URL**: https://apify.com/tagadanar/gelbeseiten-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 listing founds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Gelbeseiten Scraper: German B2B Leads with Phone, Email and Address

Turn a Gelbeseiten search into a clean B2B lead list. Give it a business term (Was) and a German location (Wo), like `steuerberater` in `berlin`, and you get back each business with its name, full address, phone, email, website and category.

Gelbeseiten.de is Germany's largest business directory. This actor reads the search results, then opens each business's own Gelbeseiten page to pull the contact data, phone and email, that is not on the results list. Everything comes back as flat JSON, one record per business, ready for a CRM or a cold-outreach list.

No browser and no login. Requests run through Apify Residential pinned to Germany by default, because the site serves German content and rate-limits by IP; that proxy usage is billed to your run at Apify cost, with nothing hidden.

### What you get per business

| Field | Description |
| --- | --- |
| `name` | Business name |
| `street`, `postalCode`, `city` | Full postal address (PLZ = German postal code) |
| `phone` | Phone number. From the business page (E.164, e.g. `+491755906782`) when available, else the number shown on the results list |
| `email` | Email, when the business published one on its Gelbeseiten profile (see the note below) |
| `website` | The business's own website |
| `category` | Gelbeseiten category (Branche), e.g. `Steuerberatung` |
| `detailUrl`, `gelbeseitenId` | The Gelbeseiten page and the internal id |
| `hasPhone`, `hasEmail` | Flags so you can filter for records that carry a contact |
| `was`, `wo` | The search term and location this record answers |
| `scrapedAt` | ISO timestamp of the run |

### Who uses it

- **B2B sales and lead-gen teams** building prospect lists for a trade in a city.
- **Local service agencies** looking for businesses in a category to pitch.
- **Market research** mapping a trade across German cities and districts.
- **Agents and data pipelines** that need German business contacts as clean JSON.

### Input examples

One trade in one city:

```json
{
  "searches": [{ "was": "steuerberater", "wo": "berlin" }],
  "maxResults": 50
}
````

Several trades and cities at once, results only (faster, no email):

```json
{
  "searches": [
    { "was": "zahnarzt", "wo": "münchen" },
    { "was": "kfz werkstatt", "wo": "10115" }
  ],
  "fetchContactDetails": false,
  "maxResults": 200
}
```

A string entry works too:

```json
{
  "searches": ["restaurant in hamburg"]
}
```

### About the email field

Emails are not guaranteed. You get an email only when the business itself published one on its Gelbeseiten profile. When there is one, the actor returns it; when there is not, `email` is blank and `hasEmail` is `false`. This is honest directory data, not an appended or guessed address, so coverage is partial and varies by trade and region. The phone number has much higher coverage than the email.

### Pricing

You pay per result. Platform usage (compute and the Germany residential proxy) is billed to your run at Apify cost, so there is no subscription and no minimum.

| Event | When it fires | Price |
| --- | --- | --- |
| `listing-found` | Each business returned | $1.00 per 1,000 |
| `contact-found` | An enriched business (detail page opened) that has a phone or an email | $4.00 per 1,000 |

`contact-found` is the enrichment charge: it fires only when `fetchContactDetails` is on and the opened business page yields a usable phone or email, so you pay the contact rate for leads you can act on. A results-only run (`fetchContactDetails: false`) never triggers it, so it is billed at the listing rate alone.

### How it works and its limits

- **Search then detail.** The actor fetches the `/suche/<was>/<wo>` page, collects the businesses and their Gelbeseiten page URLs, then opens each page for the email and canonical contact fields. Set `fetchContactDetails` to `false` to skip the per-business fetch: you still get name, category, phone, website and address from the results list, with no email. That run does one request per search instead of one per business and is billed at the `listing-found` rate only (no `contact-found`), so it is cheaper on both proxy usage and event fees.
- **Pagination.** The results page shows about 50 businesses out of the total for that search. To go beyond 50, the actor follows Gelbeseiten's own "Mehr Anzeigen" control (its `/ajaxsuche` continuation), reading the exact paging parameters from the page rather than guessing them, and stops as soon as the site stops returning new results. If you set `maxResults` to 50 or below, only the first page is fetched.
- **Locations.** `wo` can be a city, a district or a postal code. Broad terms return more businesses; narrow ones return fewer but more targeted.

### FAQ

**Is the email always there?** No. See "About the email field" above. Email is published by the business on its own profile, so coverage is partial. Phone coverage is high.

**Why a Germany proxy?** Gelbeseiten serves German content and rate-limits by IP. Residential pinned to Germany keeps requests clean. You can override or disable the proxy in the input.

**How do I get more than 50 businesses for one search?** Raise `maxResults` above 50 and the actor follows the site's "Mehr Anzeigen" pagination until it reaches your cap or the results run out. You can also add more `searches` entries (other cities or districts).

**Can I run it cheaply?** Yes. Set `fetchContactDetails` to `false` for a results-only run (name, category, phone, website, address, no email). It does one request per search instead of one per business and is billed at the `listing-found` rate only, with no `contact-found` charge.

***

### Something missing?

If you need an extra field, another source, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More data and lead generation Actors are on [my profile](https://apify.com/tagadanar).

*Gelbe Seiten scraper, Gelbeseiten scraper, German business leads, Firmenadressen scrapen, Branchenbuch scraper, German business emails, B2B leads Germany, German company contacts, Yellow Pages Germany scraper, scrape gelbeseiten.de, Steuerberater Handwerker Zahnarzt leads.*

# Actor input Schema

## `searches` (type: `array`):

One entry per search. Each entry is an object with a business term <code>was</code> and a German location <code>wo</code>, e.g. <code>{"was": "steuerberater", "wo": "berlin"}</code>. <code>wo</code> can be a city, district or postal code. A plain string like <code>"steuerberater in berlin"</code> also works. Add several entries to cover multiple trades or cities.

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

Total businesses to return across all searches. Each business costs one detail-page fetch when contact details are on, so raise this only when you need the extra volume.

## `fetchContactDetails` (type: `boolean`):

When on, the actor opens each business's Gelbeseiten page to pull the email and the canonical phone/website/address, and charges the contact-found event for enriched leads. Turn off for a faster, cheaper run billed at the listing rate only: name, category, phone, website and address from the results page, no email and no contact-found charge.

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

Gelbeseiten serves German content and rate-limits by IP. Residential pinned to Germany is recommended and used by default. You pay Apify platform usage for proxied requests.

## Actor input object example

```json
{
  "searches": [
    {
      "was": "steuerberater",
      "wo": "berlin"
    }
  ],
  "maxResults": 20,
  "fetchContactDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `businesses` (type: `string`):

One item per business found, with address and contact fields.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searches": [
        {
            "was": "steuerberater",
            "wo": "berlin"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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 = { "searches": [{
            "was": "steuerberater",
            "wo": "berlin",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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 '{
  "searches": [
    {
      "was": "steuerberater",
      "wo": "berlin"
    }
  ]
}' |
apify call tagadanar/gelbeseiten-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gelbe Seiten Scraper 🇩🇪 (German B2B leads: phone & email)",
        "description": "Turn a Gelbeseiten search into a clean B2B lead list. Give a business term (Was) and a German location (Wo); get each business with name, address, phone, email, website and category. Phone and email are pulled from the business page. Pay per result, no subscription.",
        "version": "0.1",
        "x-build-id": "govTHr8nQ5qQmGKs1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~gelbeseiten-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-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/tagadanar~gelbeseiten-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-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/tagadanar~gelbeseiten-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-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",
                "required": [
                    "searches"
                ],
                "properties": {
                    "searches": {
                        "title": "Searches (Was + Wo)",
                        "minItems": 1,
                        "type": "array",
                        "description": "One entry per search. Each entry is an object with a business term <code>was</code> and a German location <code>wo</code>, e.g. <code>{\"was\": \"steuerberater\", \"wo\": \"berlin\"}</code>. <code>wo</code> can be a city, district or postal code. A plain string like <code>\"steuerberater in berlin\"</code> also works. Add several entries to cover multiple trades or cities."
                    },
                    "maxResults": {
                        "title": "Max businesses",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Total businesses to return across all searches. Each business costs one detail-page fetch when contact details are on, so raise this only when you need the extra volume.",
                        "default": 20
                    },
                    "fetchContactDetails": {
                        "title": "Fetch email + full contact from each business page",
                        "type": "boolean",
                        "description": "When on, the actor opens each business's Gelbeseiten page to pull the email and the canonical phone/website/address, and charges the contact-found event for enriched leads. Turn off for a faster, cheaper run billed at the listing rate only: name, category, phone, website and address from the results page, no email and no contact-found charge.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Gelbeseiten serves German content and rate-limits by IP. Residential pinned to Germany is recommended and used by default. You pay Apify platform usage for proxied requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "DE"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
