# Herold.at Scraper - Austrian Business Directory (`studio-amba/herold-at-scraper`) Actor

Scrape Austrian business listings from Herold.at (Austria yellow pages). Get names, categories, addresses, phone numbers, emails, and websites by trade and city. No login needed.

- **URL**: https://apify.com/studio-amba/herold-at-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result scrapeds

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

## Herold.at Scraper — Austrian Business Directory Data

Scrape business listings from [Herold.at](https://www.herold.at), Austria's yellow pages directory. Search by trade/category keyword and city, and export clean structured business records with names, categories, addresses, phone numbers, emails, websites, and ratings. No login, no cookies, no API key.

### Why use this actor?

Herold.at is the reference business directory for Austria. Installers, electricians, tax advisors, doctors, restaurants, garages: if a business wants to be found in Austria, it is listed on Herold. Because Herold serves contact details openly (phone, email, and website are all rendered server-side per listing, not hidden behind a click), a single results-page fetch already returns near-complete records for most businesses.

Typical uses:

- **Lead generation** — build prospect lists for a trade and Austrian city, ready for a CRM import.
- **Local market research** — count and map businesses per category and region, compare cities.
- **Data enrichment** — match business names to addresses, phone numbers, emails, websites, and ratings.
- **Competitor analysis** — list every provider in a category around a city, sorted with ratings.

The actor reads the server-rendered results pages directly, so records are complete and consistent. It only returns contact details that businesses publish openly on the directory.

### How to scrape Herold.at data

1. Open the actor and set a **Trade / Category (Branche)** — the keyword exactly as it appears in the Herold.at URL, such as `installateur`, `elektriker`, `zahnarzt`, or `friseur`.
2. Set a **City (Stadt)** — an Austrian city or town (`wien`, `graz`, `linz`, `salzburg`).
3. Set **Max Results** to the number of businesses you want.
4. Leave **Fetch detail pages for missing contact info** off unless you specifically need the small number of businesses whose email or website is not already on the results page.
5. Keep the datacenter proxy prefill and click **Start** — Herold.at shows no anti-bot protection, so datacenter proxies work reliably.
6. When the run finishes, export the dataset as JSON, CSV, or Excel, or pull it from the Apify API.

The actor loads the first results page and then pages through `/seite/2/`, `/seite/3/`, and so on automatically until it reaches your Max Results or runs out of matching businesses.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Trade or category keyword in German, exactly as used in the Herold.at URL (e.g. `installateur`, `elektriker`). Defaults to `installateur` if empty. |
| `location` | String | No | Austrian city or town (e.g. `wien`, `graz`). Defaults to `wien` if empty. |
| `fetchDetails` | Boolean | No | When true, fetch each business's detail page to fill in email/website for the small share of listings missing them on the results page. Default `false`. |
| `maxResults` | Integer | No | Maximum number of businesses to return (default: 100, max: 2000). |
| `proxyConfiguration` | Object | No | Proxy settings. Datacenter proxies are sufficient — no anti-bot protection observed on Herold.at. |

Example input:

```json
{
    "searchQuery": "installateur",
    "location": "wien",
    "fetchDetails": false,
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
````

### Output

One record per business listing:

| Field | Type | Description |
|-------|------|-------------|
| `businessName` | String | Business name as listed on Herold.at |
| `category` | String | Trade/category (Branche) this listing was found under, e.g. `Installateur` |
| `address` | String | Street address, when published on the listing |
| `zipCode` | String | Austrian postal code (PLZ) |
| `city` | String | City |
| `phone` | String | Phone number, when publicly listed |
| `website` | String | Business's own website, when published |
| `email` | String | Business email address, when published |
| `listingText` | String | Short free-text presentation from the listing |
| `rating` | Number | Average customer rating (0–5), when shown |
| `reviewCount` | Number | Number of customer reviews, when shown |
| `url` | String | Full URL of the business profile on Herold.at |
| `businessId` | String | Internal Herold.at listing ID |
| `searchQuery` | String | The keyword that returned this business |
| `searchLocation` | String | The city used for the search |
| `scrapedAt` | String | ISO timestamp of the scrape |

Example output:

```json
{
    "businessName": "Lugar Installateur GmbH",
    "category": "Installateur",
    "address": "Triester Straße 346",
    "zipCode": "1230",
    "city": "Wien",
    "phone": "+43 1 8862759",
    "website": "https://www.lugar.at/wien23/",
    "email": "office@lugar.at",
    "listingText": "Ihr Spezialist für Bad-Badrenovierung-Heizung-Sanitär-Wärmepumpen-Notdienst. Über 20 Jahre Berufserfahrung. Alles aus einer Hand.",
    "rating": 4.5,
    "reviewCount": 28,
    "url": "https://www.herold.at/gelbe-seiten/wien/N1JdH/lugar-installateur-gmbh/",
    "businessId": "516863",
    "searchQuery": "installateur",
    "searchLocation": "wien",
    "scrapedAt": "2026-07-13T00:18:06.854Z"
}
```

### Cost estimate

The actor uses lightweight HTTP requests (no browser) and datacenter proxies. Each results page carries around 31 listings with phone, email, and website already inline, so most runs need one request per ~30 businesses. A 100-result run typically finishes in well under a minute and uses only a few cents of platform credits plus the per-result fee. Turning on `fetchDetails` adds one extra request only for the small share of businesses missing email or website, so cost stays close to the base run.

### Tips

- Search keywords and city names are the same words you would type into the Herold.at URL. German trade keywords match best (`installateur`, not "plumber").
- Most businesses already publish phone, email, and website on the results page — leave `fetchDetails` off for the fastest, cheapest run and turn it on only if you need to chase the remaining gaps.
- `rating` and `reviewCount` only appear when the business has published customer reviews; expect them on a subset of records.
- Multi-word cities work the same way Herold.at expects them, lowercase with spaces (e.g. `bad ischl`).

### Limitations

- The actor scrapes the results-list pages (plus optional detail-page enrichment); fields that only exist elsewhere on Herold.at (opening-hours tables, photo galleries) are not included.
- Herold.at covers Austria only.
- `category` reflects the trade/category you searched under, not a business's full self-declared category list — Herold.at does not expose a per-listing category tag on the results page.

### Related Scrapers

- [Gelbe Seiten Scraper](https://apify.com/studio-amba/gelbeseiten-scraper) — German yellow pages business directory
- [Europages Scraper](https://apify.com/studio-amba/europages-scraper) — European B2B suppliers data
- [Firmenbuch / Austrian Company Search](https://apify.com/studio-amba/firmenbuch-scraper) — Austrian official business registry
- [PagesJaunes Scraper](https://apify.com/studio-amba/pagesjaunes-scraper) — French business directory & contact info

### Legal

This actor only extracts business information that is publicly listed on the Herold.at directory, where businesses publish it precisely to be found and contacted. No login is bypassed and no private data is collected. You are responsible for using the data in compliance with applicable laws (GDPR, competition law) in your jurisdiction.

# Actor input Schema

## `searchQuery` (type: `string`):

Trade or category keyword in German, exactly as it appears in the Herold.at URL (e.g. 'installateur', 'elektriker', 'zahnarzt', 'friseur').

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

Austrian city or town to search in (e.g. 'wien', 'graz', 'linz', 'salzburg').

## `fetchDetails` (type: `boolean`):

When a listing's email or website is not already present on the results page, fetch that business's detail page to try to fill it in. This adds one extra request per business that needs it, so larger runs take longer.

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

Maximum number of businesses to return.

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

Proxy settings. Herold.at shows no anti-bot protection, so datacenter proxies work fine.

## Actor input object example

```json
{
  "searchQuery": "installateur",
  "location": "wien",
  "fetchDetails": false,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "installateur",
    "location": "wien",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/herold-at-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 = {
    "searchQuery": "installateur",
    "location": "wien",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/herold-at-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 '{
  "searchQuery": "installateur",
  "location": "wien",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/herold-at-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Herold.at Scraper - Austrian Business Directory",
        "description": "Scrape Austrian business listings from Herold.at (Austria yellow pages). Get names, categories, addresses, phone numbers, emails, and websites by trade and city. No login needed.",
        "version": "0.1",
        "x-build-id": "DPh41GoZ0sPvKshfz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~herold-at-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-herold-at-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/studio-amba~herold-at-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-herold-at-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/studio-amba~herold-at-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-herold-at-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Trade / Category (Branche)",
                        "type": "string",
                        "description": "Trade or category keyword in German, exactly as it appears in the Herold.at URL (e.g. 'installateur', 'elektriker', 'zahnarzt', 'friseur').",
                        "default": "installateur"
                    },
                    "location": {
                        "title": "City (Stadt)",
                        "type": "string",
                        "description": "Austrian city or town to search in (e.g. 'wien', 'graz', 'linz', 'salzburg').",
                        "default": "wien"
                    },
                    "fetchDetails": {
                        "title": "Fetch detail pages for missing contact info",
                        "type": "boolean",
                        "description": "When a listing's email or website is not already present on the results page, fetch that business's detail page to try to fill it in. This adds one extra request per business that needs it, so larger runs take longer.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of businesses to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Herold.at shows no anti-bot protection, so datacenter proxies work fine.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
