# 11880.com Scraper (`mlg14/com-scraper`) Actor

Search German business listings on 11880.com by keyword and city. Export names, contact details, addresses, ratings, prices, images, and optional website, coordinates, and hours.

- **URL**: https://apify.com/mlg14/com-scraper.md
- **Developed by:** [MLG Data](https://apify.com/mlg14) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 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.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 11880.com Scraper

Search 11880.com business listings by keyword and German city, then export names, public contact details, addresses, ratings, and listing links to CSV, JSON, or Excel. This 11880.com scraper provides a repeatable way to collect local business search results and, when requested, adds public website links, map coordinates, fax numbers, and opening hours from each business page.

A search can cover several keywords and several cities in one run. The actor combines every keyword with every city, follows the accessible result pages, and removes duplicate businesses before writing the dataset. A limit on total results keeps small research jobs predictable. You can use the output for local market mapping, directory quality checks, and business category research.

### What data can you extract from 11880.com?

Each result is one public business listing. The fields below are flat, so they work directly in a spreadsheet or a data pipeline. A value can be `null` when the listing does not publish it. Detail fields remain empty unless `includeDetails` is enabled.

| Field | Description | Example |
| --- | --- | --- |
| `businessId` | Stable identifier from the listing URL | `140802420B100906540` |
| `name` | Business name shown in the directory | `Estrel Hotel` |
| `businessUrl` | Direct 11880.com listing link | `https://www.11880.com/branchenbuch/berlin/...` |
| `businessType` | Type in the page's structured listing data | `LocalBusiness` |
| `phone` | Public business telephone number | `(030) 6831-0` |
| `email` | Public business email address | `reservierung@estrel.com` |
| `streetAddress` | Street and house number | `Sonnenallee 225` |
| `postalCode` | Postal code | `12059` |
| `city` | City in the listing address | `Berlin` |
| `region` | State or region in the address | `Berlin` |
| `country` | Country code | `DE` |
| `rating` | Aggregate rating where shown | `4.39` |
| `reviewCount` | Count behind the aggregate rating | `46` |
| `priceRange` | Directory price band, when supplied | `€€€` |
| `imageUrl` | Public listing image | `https://cdn.11880.com/...webp` |
| `searchQuery` | Keyword that found the listing | `Hotel` |
| `searchCity` | City used for the search | `Berlin` |
| `searchPage` | Page number that found the listing | `1` |
| `websiteUrl` | External website from the detail page | `http://estrel.com` |
| `latitude` | Detail page latitude | `52.473627` |
| `longitude` | Detail page longitude | `13.45885` |
| `fax` | Public fax number, if shown | `(030) 6831-2345` |
| `openingHours` | Day and time strings from detail data | `["Monday: 00:00-24:00"]` |

The `businessId` comes from the URL segment that identifies the directory entry. `businessUrl` is the safest link to retain for later verification. `searchQuery`, `searchCity`, and `searchPage` describe where the actor found the business; they are search context, not a claim about the business's official category or service area. `businessType` is a broad structured data type and can say `LocalBusiness` even for a hotel.

Contact data is copied only when the public listing publishes it. The actor does not infer email addresses, expand masked telephone numbers, or visit a business's external website. Ratings are the directory's aggregate values at the time of collection, and they may change after the run. The price range is a symbolic directory band rather than a room rate, menu price, or quoted service price.

### How to scrape 11880.com

1. Enter one or more business keywords in `queries`. Use terms that resemble a directory search, such as `Hotel`, `Friseur`, or `Restaurant`.
2. Enter German cities in `cities`. The actor searches each keyword in each city, so two keywords and three cities create six separate searches.
3. Set `maxItems` for the total number of unique businesses you want. Set `maxPagesPerSearch` between one and five. Turn on `includeDetails` if website links, coordinates, fax, or opening hours are needed.
4. Run the actor. It writes one dataset item for each unique business and stops at the total limit or when the selected search pages are exhausted.
5. Open the resulting dataset and export it as JSON, CSV, or Excel. Keep `businessUrl` with your export so you can revisit a record and check changes.

Start with one keyword and one city to check whether the results match your research question. Broader searches can contain sponsored or nearby listings. A focused keyword gives you a smaller review task before you increase the number of pages or cities.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | Array of strings | Required | Business keywords. Each is searched in every selected city. |
| `cities` | Array of strings | `['Berlin']` | German cities to search. |
| `maxItems` | Integer | `100` | Maximum unique businesses across the whole run; `0` removes this total cap. |
| `maxPagesPerSearch` | Integer | `2` | Maximum pages for each keyword and city pair, from one to five. A page contains up to 50 listings. |
| `includeDetails` | Boolean | `false` | Opens each business page to add external website, coordinates, fax, and hours when published. |
| `proxyConfiguration` | Object | Enabled | Connection settings for requests to the directory. |

A practical starting input is:

```json
{
  "queries": ["Hotel", "Friseur"],
  "cities": ["Berlin", "Hamburg"],
  "maxItems": 120,
  "maxPagesPerSearch": 2,
  "includeDetails": false
}
```

This input can stop before all four search combinations are finished because `maxItems` is a total cap. The actor visits combinations in the order of `queries`, then `cities`. For a balanced sample from several places, make separate runs with a limit for each city. If you need a larger collection, increase the page limit to five and add narrower terms or more cities. Setting `maxItems` to zero does not remove the five-page limit per search.

The actor converts German umlauts and `ß` into common URL spellings for search paths. For example, `München` becomes `muenchen`. Use the spelling visible in 11880.com URLs when a local place or category has several possible names. Search terms are submitted as directory paths, so highly unusual punctuation is simplified.

### Output example

The following item came from a successful 60-result run for `Hotel` in `Berlin`, limited to two pages. It is shortened to show the key fields. Detail enrichment was disabled in that run.

```json
{
  "businessId": "140802420B100906540",
  "name": "Estrel Hotel",
  "businessUrl": "https://www.11880.com/branchenbuch/berlin/140802420B100906540/estrel-hotel.html",
  "businessType": "LocalBusiness",
  "phone": "(030) 6831-0",
  "email": "reservierung@estrel.com",
  "streetAddress": "Sonnenallee 225",
  "postalCode": "12059",
  "city": "Berlin",
  "region": "Berlin",
  "country": "DE",
  "rating": 4.39,
  "reviewCount": 46,
  "priceRange": "€€€",
  "searchQuery": "Hotel",
  "searchCity": "Berlin",
  "searchPage": 1,
  "websiteUrl": null,
  "openingHours": []
}
```

The golden run returned 60 unique records and met all required fill thresholds for identifiers, names, URLs, phone, email, address, city, and search context. That result demonstrates the two-page path for this search at the time of testing. It does not promise the same count or field availability for every category, city, or later date.

### Use cases

- **Local market maps:** Compare how many directory entries a category returns across German cities, then review addresses and listing URLs for geographic coverage.
- **Directory audits:** Check whether a public business listing has an address, phone number, email, image, price band, and rating; flag missing fields for manual follow-up.
- **Competitor research:** Build a shortlist of publicly listed businesses in a city, review ratings and price bands, and open the original directory pages for context.
- **Territory planning:** Combine a category with several cities to see where the directory has dense or sparse results. Keep the query and city columns so separate searches remain traceable.
- **Hospitality research:** Collect hotel listings with public ratings, review counts, contact channels, and symbolic price bands. Enable details when coordinates or opening hours matter.
- **Data refreshes:** Schedule the same input periodically and compare business IDs and public fields between exports. Use the listing URL to verify any apparent change.

These workflows depend on the public directory data that is actually available. A listing is a research lead, not proof that a business is operating, that contact information is current, or that the search term precisely describes its services. Review the directory entry before making a business decision.

### How much does it cost to scrape 11880.com?

The configured price is **$1.00 per 1,000 delivered results**, or **$0.001 per dataset item**. Results are billed when written to the dataset. The displayed charge is based on delivered results, while the number of page requests depends on your input and whether detail enrichment is enabled. Platform usage is included in this result price.

| Delivered businesses | Result charge |
| ---: | ---: |
| 60 | $0.06 |
| 1,000 | $1.00 |
| 5,000 | $5.00 |

The 60-result example requires at least two search pages because one page holds up to 50 entries. A run with detail enrichment opens up to one additional directory page per business. That usually takes longer than a search-only run. A run can also use several search pages while yielding fewer new businesses because the same listing may appear under several keywords or cities. Deduplication means repeated listings are not written twice.

Plan the result limit around the question you need to answer. For an initial check, 50 to 100 businesses is enough to inspect coverage and field quality. For a larger collection, keep the keyword and city list narrow enough that you can inspect a sample from each segment.

### Tips for best results

Use a German category word that appears in the directory's own search paths. `Hotel` and `Friseur` returned full pages in the tested cities. A very broad term can mix related, sponsored, and nearby businesses. If you need a precise service type, review a sample of results and adjust the keyword rather than assuming every match is a strict category member.

Start with `maxPagesPerSearch: 2`. The site returned 50 structured listings per page in the tested searches. Increase to five when the first pages are relevant and you need more coverage. For more than roughly 250 entries from one category and city, split the research into narrower terms or additional cities. Do not expect a high `maxItems` value by itself to bypass the site's per-search page boundary.

Leave `includeDetails` off when names, addresses, contact fields, ratings, and links are enough. The search results already contain those fields. Turn it on for external website URLs, coordinates, fax, and opening hours, then expect more requests and a longer run. Some detail pages do not publish every enriched field, so `null` and empty arrays are normal.

For repeatable exports, retain `businessId`, `businessUrl`, `searchQuery`, and `searchCity`. IDs support deduplication across runs, URLs let you verify a record, and search context explains why an entry appeared. Avoid treating a missing rating as a zero rating: `null` means the aggregate value was unavailable.

### Limits

The accessible search interface returned up to 50 structured business entries per page and redirected page six back to page one in the tested `Hotel` and `Berlin` search. The actor therefore stops at five pages per keyword and city pair. The search page may display a larger hit count than the number that can be collected through those pages. Narrower searches and additional cities are the practical way to cover more of the directory.

Search results can include promoted or nearby listings. One entry found by a keyword is not guaranteed to belong exclusively to that category. The actor preserves the source listing rather than inventing a category classification. A business appearing in multiple combinations is emitted once, with the context of the first occurrence.

Some public fields are optional. Ratings, review counts, image URLs, and symbolic price bands may be absent. Detail enrichment can add website, coordinates, fax, and hours only when the detail page exposes them. Detail failures leave the base search record intact. Search pages or detail pages may block a request, and the actor retries through another connection; a segment that remains unavailable can yield fewer results than requested.

The actor is intended for public business listings. It does not collect account-only pages, private contact information, individual person searches, review bodies, or data from external business websites. The data reflects what 11880.com showed during the run and is not an independently verified company register.

### Use with automation

A scheduled run can produce a fresh directory dataset for a fixed keyword and city list. A downstream workflow can ask for all hotel listings in Berlin with at least ten reviews, or for listings in Hamburg that publish a telephone number but no external website link. Keep the original listing URL in the workflow so a reviewer can open the source when a field looks unusual.

Two example requests for a connected workflow are: “Collect up to 100 hotel listings in Berlin and show the names, ratings, review counts, and listing links.” “Collect up to 50 hairdresser listings in Hamburg, include public website links where available, and return a CSV with addresses.” The second request should enable detail enrichment because external websites do not come from the search results alone.

### FAQ

**Is this suitable for public business research?** Yes. It reads public directory listings. Follow applicable terms, privacy rules, and local law, and avoid using contact data for unwanted outreach or personal data misuse.

**Do I need to configure a proxy?** The default proxy setting is sufficient for the tested run. Search pages blocked the initial datacenter route during probing, so the actor escalates to a German residential route after repeated blocks. Custom connection settings are available if your account requires them.

**How fast is a run?** Search-only runs request one page for each group of up to 50 listings. The tested 60-result run finished successfully. Detail enrichment adds a request for each emitted business and can take considerably longer, especially when the site slows or blocks requests.

**Can I get more than 250 businesses for a category in one city?** The tested search path stopped after five pages of up to 50 entries. Use narrower category phrases or additional cities, then deduplicate by `businessId` in your analysis if you combine multiple exports.

**Can I schedule or monitor collections?** Yes. Save the input and schedule repeated runs, then compare the dataset counts and key fill rates. Treat a sharp count drop as a signal to inspect the source pages and run logs.

**Can I export to a spreadsheet?** Yes. Download the dataset as CSV or Excel, or use JSON for a programmatic workflow. The output fields are flat except for the optional `openingHours` string array.

**Why are website, coordinates, or opening hours empty?** Detail enrichment is off by default. Enable `includeDetails` to visit the business page. A field can still be empty when the public page omits it or the detail request is unavailable.

### Integrations

Use the dataset URL with an API client, a webhook, a scheduled job, or a spreadsheet import. The flat fields also fit common workflow builders and data warehouses. For incremental comparisons, store `businessId` and the time of your export in your own system; the actor writes current snapshots and does not maintain a historical change log.

### Support

Open an issue on the Issues tab; we reply within 24h and add fields on request.

# Actor input Schema

## `queries` (type: `array`):

German business types or company keywords to search, such as Hotel or Friseur. Each query is searched in every city.

## `cities` (type: `array`):

Cities to search, such as Berlin or Hamburg. Each city is combined with every keyword.

## `maxItems` (type: `integer`):

Maximum unique businesses across all searches. Set 0 for no total cap.

## `maxPagesPerSearch` (type: `integer`):

Maximum search pages per keyword and city pair. Each page holds up to 50 listings; the site currently redirects after page 5.

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

Open each business page to add its public website, coordinates, fax, and opening hours. This uses more requests and takes longer.

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

Use the configured proxy for 11880.com requests. The actor starts with datacenter and escalates to a German residential address after blocks.

## Actor input object example

```json
{
  "queries": [
    "Hotel",
    "Friseur"
  ],
  "cities": [
    "Berlin",
    "Hamburg"
  ],
  "maxItems": 100,
  "maxPagesPerSearch": 2,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Unique business listings in the default dataset.

# 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 = {
    "queries": [
        "Hotel",
        "Friseur"
    ],
    "cities": [
        "Berlin",
        "Hamburg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mlg14/com-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 = {
    "queries": [
        "Hotel",
        "Friseur",
    ],
    "cities": [
        "Berlin",
        "Hamburg",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("mlg14/com-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 '{
  "queries": [
    "Hotel",
    "Friseur"
  ],
  "cities": [
    "Berlin",
    "Hamburg"
  ]
}' |
apify call mlg14/com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mlg14/com-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/KRyQQmBxQfJoTEhUW/builds/r2eZiHOgcW0mkI0CR/openapi.json