# Herold.at Scraper (`solidcode/herold-at-scraper`) Actor

\[💰 $1.5 / 1K] Extract Austrian business listings from Herold.at — name, address, phone, email, website, categories, opening hours, rating, and review count, plus optional individual customer reviews. Search by what + where, browse by category, or paste Herold.at URLs directly.

- **URL**: https://apify.com/solidcode/herold-at-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

Pull Austrian business listings from Herold.at at scale — company names, full structured addresses, phone, email, website, Facebook, categories, opening hours, GPS coordinates, ratings, and every individual customer review. Built for lead-generation teams, market researchers, and sales prospectors who need accurate Austrian business and reputation data without copy-pasting it out of the directory one profile at a time.

### Why This Scraper?

- **All 9 Austrian states in one actor** — Wien, Niederösterreich, Oberösterreich, Steiermark, Tirol, Salzburg, Kärnten, Vorarlberg, and Burgenland, or leave the location empty to sweep the whole country.
- **Four contact channels in every row** — phone, email, website, and Facebook captured side by side, so each business is a ready-to-use lead the moment it lands.
- **Individual customer reviews with per-category sub-scores** — flip on `includeReviews` and every review becomes its own row: reviewer, title, full text, date, and star scores broken out by Qualität, Service, Preis, Ambiente, Freundlichkeit, and more.
- **Firmenbuchnummer (company register number)** — the official Austrian company register ID is captured on detail-enriched rows, alongside founding year for company-verification and KYC workflows.
- **Verified-business badge** — every row flags whether Herold marks the listing as "Verifiziert", so you can filter for confirmed, actively-managed profiles.
- **Six-part structured address plus GPS coordinates** — street, postal code, city, district (Bezirk), state (Bundesland), and country split into separate fields, plus latitude and longitude for instant mapping wherever Herold publishes them.
- **Full opening-hours table** — per-day open/close times plus any free-text hours note, captured on detail-enriched rows.
- **Aggregate rating and review count on every business** — average star rating and the number of ratings behind it, even when you skip individual reviews for a cheaper run.
- **Search by what + where, or paste any Herold.at URL** — keyword/category terms paired with an Austrian region, or drop in listing, category, and business-profile URLs and have their built-in filters honored as-is.

### Use Cases

**Lead Generation**
- Build B2B contact lists with phone, email, website, and Facebook in a single export
- Target a whole category across a Bundesland (every Zahnarzt in Steiermark, every Elektriker in Tirol)
- Filter for verified businesses to prioritize actively-managed profiles
- Enrich existing CRM records with current Austrian contact details

**Market Research**
- Map business density by category across all 9 Austrian states
- Size a local market by counting listings per region and city
- Track which categories dominate a given district (Bezirk)
- Benchmark opening hours and contact-channel coverage across an industry

**Competitive & Reputation Analysis**
- Pull every customer review for a competitor with per-category star scores
- Compare average ratings and review volume across rivals in the same category
- Surface recurring praise and complaints from full-text review bodies
- Monitor a brand's verified status and review trend over time

**Sales Prospecting**
- Find newly listed or recently founded companies via founding year
- Verify a prospect's official identity with the Firmenbuchnummer
- Geo-target outreach using latitude/longitude and district data
- Prioritize leads by rating and review count before the first call

**Data Enrichment & Integration**
- Feed structured Austrian business data into analytics dashboards
- Power local-search and directory products with fresh listings
- Geocode existing company lists using captured coordinates
- Append opening hours and social links to partner databases

### Getting Started

#### Simple — one category, one region

The fastest way to start: what to find, and where in Austria.

```json
{
    "searchQueries": ["Restaurant"],
    "location": "Wien",
    "maxResults": 50
}
````

#### Company-only pull (cheaper, no reviews)

Turn off detail enrichment and reviews for a fast, low-cost sweep of listing data.

```json
{
    "searchQueries": ["Zahnarzt", "Apotheke"],
    "location": "Steiermark",
    "includeDetails": false,
    "includeReviews": false,
    "maxResults": 200
}
```

#### Full intelligence — businesses plus every review

Enrich each business and collect every individual customer review as its own row.

```json
{
    "searchQueries": ["Hotel"],
    "location": "Tirol",
    "includeDetails": true,
    "includeReviews": true,
    "maxResults": 100
}
```

#### Paste Herold.at URLs directly

Drop in listing, category, or business-profile URLs — their built-in filters are honored as-is.

```json
{
    "searchUrls": [
        "https://www.herold.at/gelbe-seiten/wien/restaurant/",
        "https://www.herold.at/gelbe-seiten/wien/RgXbM/ddr-endre-und-dr-nora-steger/"
    ],
    "includeReviews": true
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["Restaurant"]` | What to search for on Herold.at — keyword or category terms such as `Restaurant`, `Zahnarzt`, `Elektriker`, `Rechtsanwalt`. One row per term. Leave empty if you're using direct URLs. |
| `location` | string | `"Wien"` | Where in Austria to search. Works best with a state/region name: Wien, Niederösterreich, Oberösterreich, Steiermark, Tirol, Salzburg, Kärnten, Vorarlberg, or Burgenland. Leave empty to search all of Austria. |
| `searchUrls` | array | `[]` | Paste Herold.at URLs directly: search/category result pages or individual business pages. Filters baked into the URL are honored as-is. Scraped in addition to the search above. |

#### Output Detail

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | Visit each business's detail page to add the full opening-hours table, business description, founding year, company register number, and additional photos. Turn off for faster, cheaper runs that return only listing data. |
| `includeReviews` | boolean | `false` | Also collect every individual customer review for each business and add each one as its own row (reviewer name, title, text, date, and per-category star scores). Turning this on automatically fetches detail pages even if `includeDetails` is off. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Hard cap on total business rows across all searches and URLs. Set to `0` for no cap (an internal upper limit of 50,000 rows per run still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. |

### Output

Every row carries a `recordType` field — either `business` or `review` — so you can split the two record types downstream. Business rows are always returned; review rows appear only when `includeReviews` is enabled, and each one links back to its parent business.

#### Business record (`recordType: "business"`)

```json
{
    "recordType": "business",
    "name": "DDr. Endre und Dr. Nora Steger",
    "categories": ["Zahnärzte", "Kieferorthopädie"],
    "description": "Zahnarztpraxis im Herzen Wiens mit Schwerpunkt Implantologie.",
    "phone": "+43 1 5121234",
    "email": "ordination@steger-dental.at",
    "website": "https://www.steger-dental.at",
    "street": "Kärntner Straße 12",
    "postalCode": "1010",
    "city": "Wien",
    "district": "Innere Stadt",
    "state": "Wien",
    "country": "AT",
    "latitude": 48.2065,
    "longitude": 16.3702,
    "rating": 4.7,
    "reviewCount": 38,
    "verified": true,
    "keywords": ["Implantate", "Zahnreinigung", "Bleaching"],
    "openingHours": [
        { "day": "Montag", "fromTime": "08:00", "toTime": "18:00" }
    ],
    "openingText": "Termine nach Vereinbarung",
    "socialLinks": { "facebook": "https://www.facebook.com/stegerdental" },
    "foundingYear": "1998",
    "companyRegisterId": "FN 123456a",
    "images": ["https://www.herold.at/img/123.jpg"],
    "logoUrl": "https://www.herold.at/img/logo-123.jpg",
    "url": "https://www.herold.at/gelbe-seiten/wien/RgXbM/ddr-endre-und-dr-nora-steger/",
    "scrapedAt": "2026-06-03T10:15:42.000Z"
}
```

**Core & Contact**

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"business"` for business rows |
| `name` | string | Business name |
| `categories` | array | Business categories / Branchen |
| `description` | string | Business description (detail-enriched) |
| `phone` | string | Primary phone number |
| `email` | string | Email address |
| `website` | string | External website URL |
| `socialLinks` | object | Social profile links, e.g. Facebook |
| `url` | string | Herold.at business-profile URL |

**Address & Location**

| Field | Type | Description |
|-------|------|-------------|
| `street` | string | Street and house number |
| `postalCode` | string | Austrian postal code |
| `city` | string | City |
| `district` | string | District / Bezirk |
| `state` | string | Region / Bundesland |
| `country` | string | Country code (e.g. `AT`) |
| `latitude` | number | Geographic latitude |
| `longitude` | number | Geographic longitude |

**Ratings & Profile Detail**

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Aggregate star rating |
| `reviewCount` | integer | Number of ratings behind the aggregate |
| `verified` | boolean | Whether Herold flags the listing "Verifiziert" |
| `keywords` | array | Business keywords / tags |
| `openingHours` | array | Per-day open/close times (detail-enriched) |
| `openingText` | string | Free-text hours note (detail-enriched) |
| `foundingYear` | string | Founding year (detail-enriched) |
| `companyRegisterId` | string | Firmenbuchnummer / company register ID (detail-enriched) |
| `images` | array | Photo URLs (detail-enriched) |
| `logoUrl` | string | Business logo URL |
| `scrapedAt` | string | ISO 8601 capture timestamp |

#### Review record (`recordType: "review"`)

```json
{
    "recordType": "review",
    "businessName": "DDr. Endre und Dr. Nora Steger",
    "author": "Maria K.",
    "title": "Sehr freundliches Team",
    "reviewText": "Kompetente Beratung und schmerzfreie Behandlung. Sehr zu empfehlen!",
    "comment": "Vielen Dank für Ihr Vertrauen!",
    "reviewDate": "2026-04-18T00:00:00.000Z",
    "ratings": [
        { "category": "Qualität", "rating": 5 },
        { "category": "Service", "rating": 5 },
        { "category": "Preis", "rating": 4 }
    ],
    "businessUrl": "https://www.herold.at/gelbe-seiten/wien/RgXbM/ddr-endre-und-dr-nora-steger/",
    "reviewId": "rev_8f3a91",
    "scrapedAt": "2026-06-03T10:15:43.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` for review rows |
| `businessName` | string | Parent business name (linkage) |
| `author` | string | Reviewer name / handle |
| `title` | string | Review title (may be empty) |
| `reviewText` | string | Free-text review body |
| `comment` | string | Business reply (often empty) |
| `reviewDate` | string | ISO 8601 review date |
| `ratings` | array | Per-category sub-scores: `{ category, rating }` |
| `businessUrl` | string | Parent business Herold.at URL (linkage) |
| `reviewId` | string | Stable review identifier |
| `scrapedAt` | string | ISO 8601 capture timestamp |

### Tips for Best Results

- **Use Austrian state names for `location`, not city names.** Wien, Steiermark, and Tirol resolve cleanly; most individual city names (other than Wien) return nothing. If you want a single city, leave `location` empty and add the city to your search term instead.
- **Turn `includeReviews` off for cheap company-only pulls.** When you only need contact and address data, leaving reviews off keeps each business to a single row and cuts the result count dramatically.
- **Reviews require detail pages.** Switching on `includeReviews` automatically fetches each business's detail page even if `includeDetails` is off — so you always get reviewer scores, but listing-only business fields stay lean if detail is disabled.
- **Split very large jobs by query or region.** Run one category per Bundesland rather than one giant nationwide sweep — you'll get cleaner, more targeted exports and finer control over volume.
- **Search categories in German.** Herold is a German-language directory: use `Restaurant`, `Zahnarzt`, `Elektriker`, `Rechtsanwalt`, `Apotheke`, `Hotel`, and similar terms.
- **Paste URLs to reuse Herold's own filters.** If you've already narrowed a search on Herold.at, paste that URL into `searchUrls` and its built-in filters are honored exactly.
- **Filter on `verified` for higher-quality leads.** Verified listings are confirmed, actively-managed profiles — a strong signal when prioritizing outreach.

### Pricing

**From $1.50 per 1,000 results** — undercutting comparable Austrian business-directory scrapers while delivering structured addresses, four contact channels, and per-category review scores. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.18 | $0.17 | $0.16 | $0.15 |
| 1,000 | $1.80 | $1.70 | $1.60 | $1.50 |
| 10,000 | $18.00 | $17.00 | $16.00 | $15.00 |
| 100,000 | $180.00 | $170.00 | $160.00 | $150.00 |

Both the businesses and the individual reviews you collect count as results — so when `includeReviews` is on, each review row is billed alongside its business, giving you full review intelligence with per-toggle control over the bill. Apify platform usage is billed separately by Apify.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available business-directory information from Herold.at. Use the data responsibly and in compliance with Herold.at's terms of service and all applicable laws, including the GDPR and Austrian data-protection regulations. Personal data contained in reviews and contact fields must be handled lawfully — obtain a valid legal basis before processing it, honor data-subject requests, and do not use the data for spam or unsolicited bulk contact. You are responsible for how you use the extracted data.

# Actor input Schema

## `searchQueries` (type: `array`):

What to search for on Herold.at (e.g. 'Restaurant', 'Zahnarzt', 'Elektriker', 'Rechtsanwalt'). One row per search term. Leave empty if you're using direct URLs below.

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

Where in Austria to search. Works best with a state / region name: 'Wien', 'Niederösterreich', 'Oberösterreich', 'Steiermark', 'Tirol', 'Salzburg', 'Kärnten', 'Vorarlberg', or 'Burgenland'. Leave empty to search all of Austria. (Tip: individual city names other than Wien may return nothing — if so, use the surrounding state, or leave this empty and add the city to your search term.)

## `searchUrls` (type: `array`):

Paste Herold.at URLs directly: search / category result pages (e.g. https://www.herold.at/gelbe-seiten/wien/restaurant/) or individual business pages. Filters baked into the URL are honored as-is. When provided, these are scraped in addition to the search above.

## `includeDetails` (type: `boolean`):

Visit each business's detail page to enrich the row with the full opening-hours table, business description, founding year, company register number, and additional photos. Turn off for faster, cheaper runs that return only the listing data (name, address, phone, email, website, rating, categories). Slower when on (one extra request per business).

## `includeReviews` (type: `boolean`):

Also collect every individual customer review for each business and add each one as its own separate row in the results (with reviewer name, title, review text, date, and per-category star scores). IMPORTANT: each review is counted and billed as a separate result. Collecting reviews requires visiting each business's detail page, so turning this on automatically fetches detail pages even if 'Include Detail-Page Data' is off. Leave off to get only one row per business with an aggregate rating and review count.

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

Hard cap on total business rows across all searches and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 50,000 rows per run still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. To gather very large datasets, split a request across multiple search queries or locations.

## Actor input object example

```json
{
  "searchQueries": [
    "Restaurant"
  ],
  "location": "Wien",
  "searchUrls": [],
  "includeDetails": true,
  "includeReviews": false,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Quick view of extracted businesses with key contact and rating fields.

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

Full payload per business including opening hours, description, founding year, register number, social links, and photos.

## `reviews` (type: `string`):

Individual customer reviews (when 'Include Individual Reviews' is enabled) — author, title, text, date, and per-category star scores, with parent business linkage.

# 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 = {
    "searchQueries": [
        "Restaurant"
    ],
    "location": "Wien",
    "searchUrls": [],
    "includeDetails": true,
    "includeReviews": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["Restaurant"],
    "location": "Wien",
    "searchUrls": [],
    "includeDetails": True,
    "includeReviews": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchQueries": [
    "Restaurant"
  ],
  "location": "Wien",
  "searchUrls": [],
  "includeDetails": true,
  "includeReviews": false,
  "maxResults": 100
}' |
apify call solidcode/herold-at-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Herold.at Scraper",
        "description": "[💰 $1.5 / 1K] Extract Austrian business listings from Herold.at — name, address, phone, email, website, categories, opening hours, rating, and review count, plus optional individual customer reviews. Search by what + where, browse by category, or paste Herold.at URLs directly.",
        "version": "1.0",
        "x-build-id": "oiGqJUeHswhJSnP5q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~herold-at-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~herold-at-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~herold-at-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "What to search for on Herold.at (e.g. 'Restaurant', 'Zahnarzt', 'Elektriker', 'Rechtsanwalt'). One row per search term. Leave empty if you're using direct URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where in Austria to search. Works best with a state / region name: 'Wien', 'Niederösterreich', 'Oberösterreich', 'Steiermark', 'Tirol', 'Salzburg', 'Kärnten', 'Vorarlberg', or 'Burgenland'. Leave empty to search all of Austria. (Tip: individual city names other than Wien may return nothing — if so, use the surrounding state, or leave this empty and add the city to your search term.)"
                    },
                    "searchUrls": {
                        "title": "Herold.at URLs",
                        "type": "array",
                        "description": "Paste Herold.at URLs directly: search / category result pages (e.g. https://www.herold.at/gelbe-seiten/wien/restaurant/) or individual business pages. Filters baked into the URL are honored as-is. When provided, these are scraped in addition to the search above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Include Detail-Page Data",
                        "type": "boolean",
                        "description": "Visit each business's detail page to enrich the row with the full opening-hours table, business description, founding year, company register number, and additional photos. Turn off for faster, cheaper runs that return only the listing data (name, address, phone, email, website, rating, categories). Slower when on (one extra request per business).",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include Individual Reviews",
                        "type": "boolean",
                        "description": "Also collect every individual customer review for each business and add each one as its own separate row in the results (with reviewer name, title, review text, date, and per-category star scores). IMPORTANT: each review is counted and billed as a separate result. Collecting reviews requires visiting each business's detail page, so turning this on automatically fetches detail pages even if 'Include Detail-Page Data' is off. Leave off to get only one row per business with an aggregate rating and review count.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total business rows across all searches and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 50,000 rows per run still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. To gather very large datasets, split a request across multiple search queries or locations.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
