# Gelbe Seiten Scraper 🇩🇪 $1/1k (German B2B leads + contacts) (`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, platform usage included.

- **URL**: https://apify.com/tagadanar/gelbeseiten-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 3 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. 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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. It reads Gelbeseiten over plain datacenter requests, so there is no residential proxy surcharge, and platform usage is included in the price: one all-in per-result rate, no separate Apify bill.

### 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 included. No separate Apify bill, no subscription.

| Event | When it fires | Price |
| --- | --- | --- |
| Actor start | Once per run | $0.001 |
| `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 |

The tiny start fee covers runs that return nothing; on any normal search it is noise next to the per-result price.

`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.
- **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.

**Does it need a proxy?** No residential proxy. Gelbeseiten answers plain datacenter requests, which the actor rotates for you to stay under the site's per-IP rate limit. There is no proxy option to configure and no residential surcharge.

**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.

## Actor input object example

```json
{
  "searches": [
    {
      "was": "steuerberater",
      "wo": "berlin"
    }
  ],
  "maxResults": 5,
  "fetchContactDetails": true
}
```

# 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"
        }
    ],
    "maxResults": 5
};

// 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",
        }],
    "maxResults": 5,
}

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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"
    }
  ],
  "maxResults": 5
}' |
apify call tagadanar/gelbeseiten-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tagadanar/gelbeseiten-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/22wbZ6GYwUfrC3SUE/builds/EXDFZCMTs0C2HwnKo/openapi.json