# mobile.de Dealer Scraper - German Car Dealer Directory (`rastriq/mobile-de-dealers`) Actor

Extract the mobile.de dealer directory by German state: dealer ID, name, full address, description and mobile.de homepage link. Plain HTTP, no proxy needed, de-duplicated dataset in JSON, CSV or Excel. Pay per dealer returned.

- **URL**: https://apify.com/rastriq/mobile-de-dealers.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 dealer returneds

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

## mobile.de Dealer Scraper

**mobile.de Dealer Scraper** extracts the public dealer directory of mobile.de, Germany's largest car marketplace: dealer ID, name, full address, dealer description and the link to each dealer's mobile.de homepage. Pick one or more German states, or crawl all 16, and get a clean, de-duplicated dataset in JSON, CSV or Excel using plain HTTP: no browser, no proxy.

> This Actor returns **dealers only**. For the vehicles themselves use [Mobile.de Scraper](https://apify.com/rastriq/mobile-de-scraper) and join both datasets on the dealer homepage.

### What data you get with mobile.de Dealer Scraper

mobile.de Dealer Scraper reads the same regional directory (`home.mobile.de/regional`) that any visitor can browse, page by page, and returns one flat record per unique dealer. Fields the source does not provide are `null`; the directory does **not** publish phone numbers or e-mail addresses, so they are not returned.

| Field | Type | Description |
|---|---|---|
| `dealerId` | s or t or r or i or n or g | mobile.de customer ID of the dealer (unique per item). |
| `name` | string (nullable) | Dealer name as listed in the directory. |
| `street` | string (nullable) | Street and number. Null if not listed. |
| `zipcode` | string (nullable) | German postal code. Null if not listed. |
| `city` | string (nullable) | City of the dealer location. |
| `state` | s or t or r or i or n or g | State slug the dealer was found under in the mobile.de regional directory (the postal address can be in a neighbouring state). |
| `description` | string (nullable) | Free-text description written by the dealer (often opening hours). Null if the dealer has none. |
| `homepageUrl` | string (nullable) | URL of the dealer's mobile.de homepage. |
| `homepageMasked` | boolean (nullable) | Flag from the source: true when the dealer hides the homepage link. Rows are kept either way. |
| `homepageOmitted` | boolean (nullable) | Flag from the source: true when no homepage is published. |
| `sourceCountry` | s or t or r or i or n or g | Marketplace country code. |
| `scrapedAt` | s or t or r or i or n or g | UTC timestamp of the run start in ISO 8601 format. |

### How to use mobile.de Dealer Scraper

1. Open **mobile.de Dealer Scraper** on Apify and click **Try for free**.
2. Choose one or more **German states** (leave empty for all 16).
3. Set **Max dealers**. The prefill (Bremen, 20 dealers) is a cheap first test; use `0` for no limit.
4. Click **Start**; no proxy is needed.
5. Download the dataset from the **Output** tab as JSON, CSV or Excel, or read it through the API.

Typical uses of mobile.de Dealer Scraper:

- Map the German dealer landscape by state, city or postal code
- Build a dealer universe to join with listing or pricing data
- Track new and disappearing dealers between runs
- Territory planning and market sizing for automotive suppliers

### Input example

The prefilled input of mobile.de Dealer Scraper (a cheap first run):

```json
{
  "states": [
    "bremen"
  ],
  "maxDealers": 20
}
```

| Parameter | Type | Default | Prefill | Description |
|---|---|---|---|---|
| `states` | array | — | `['bremen']` | Select one or more states (Bundesländer). Leave empty to crawl all 16 states. Bremen is the smallest (about 130 dealers) and a good first test. |
| `maxDealers` | integer | `100` | `20` | Maximum number of dealers to return in total. You are charged per dealer ($0.002 each), so use a low value for a first test, for example `20`. Set 0 for no limit (about 29,000 unique dealers for all 16 states, roughly $58). |
| `requestDelayMin` | integer | `500` | — | Minimum pause between two page requests. |
| `requestDelayMax` | integer | `1000` | — | Maximum pause between two page requests (random jitter between min and max). |
| `maxConcurrency` | integer | `1` | — | Parallel requests. Keep it low (1-3) to stay polite with the source. |
| `proxyConfiguration` | object | — | — | No proxy is needed: the dealer directory works from standard datacenter IPs and no residential traffic is billed. Only select Apify Proxy if you see repeated HTTP 403 errors. |

### Output example

A real record returned by mobile.de Dealer Scraper:

```json
{
  "dealerId": "462887",
  "name": "Autocenter Gehrmann GmbH",
  "street": "Weimarische Strasse 1b",
  "zipcode": "07407",
  "city": "Rudolstadt",
  "state": "thüringen",
  "description": "Gebrauchtwagenhändler",
  "homepageUrl": "https://home.mobile.de/AUTOCENTER-GEHRMANN",
  "homepageMasked": false,
  "homepageOmitted": false,
  "sourceCountry": "DE",
  "scrapedAt": "2026-10-24T20:20:16.900Z"
}
```

A `SUMMARY` record in the key-value store lists, for every state, the dealer count reported by mobile.de (`sourceResultCount`), the pages fetched and the dealers returned (`pushed`).

### Pricing

mobile.de Dealer Scraper uses pay-per-event pricing: **$0.005 per run start** plus **$0.002 per dealer** ($2.00 per 1,000). You only pay for unique dealers delivered to the dataset, after de-duplication.

| Run | Cost in events |
|---|---|
| 20 dealers (prefill) | $0.045 |
| 100 dealers (default run) | $0.205 |
| 1,000 dealers | $2.005 |
| All of Germany (about 29,000 dealers) | about $58 |

No proxy is used, so there is no extra proxy cost; platform compute for a 1,000-dealer run is well below one cent.

### Limitations

- **The mobile.de counter overstates the list by about 5 to 22 %.** The total shown for a state is higher than the dealers its paginated list actually returns: Berlin 751 shown vs 716 returned, Thüringen 727 vs 692, Bremen 162 vs 127. The Actor returns what the directory lists and reports both numbers in `SUMMARY`; the 16 state counters add up to 31,535, while we estimate about 29,000 unique dealers (a full 16-state crawl was not run in our tests).
- About half of the dealers have no description (`null`): 496 of 1,000 in our test.
- Dealers are grouped by the directory region they appear in; the postal address can be in a neighbouring state.
- `homepageMasked` and `homepageOmitted` are source flags; rows are kept either way.
- Data is a point-in-time snapshot of a public directory. Transient HTTP 403 responses are retried up to 5 times; pages that still fail are counted in `SUMMARY.pagesFailed`.

### Related Actors

| Country | Actor | Notes |
|---|---|---|
| Germany | [Mobile.de Scraper](https://apify.com/rastriq/mobile-de-scraper) | vehicle listings |
| Spain | [coches.net Dealer Scraper](https://apify.com/rastriq/coches-net-dealers) | dealer directory by province |
| Spain | [Coches.net Scraper](https://apify.com/rastriq/cochesnet-spain) | vehicle listings |
| Europe | [AutoScout24 Scraper](https://apify.com/rastriq/autoscout24-scraper) | vehicle listings, 8 countries |

### FAQ

**Is it legal to scrape mobile.de dealers?** mobile.de Dealer Scraper reads public directory pages that are not excluded in the `robots.txt` of home.mobile.de, and returns business listings. You are responsible for using the data in line with the website terms and with GDPR/UWG. Some dealers are sole traders whose name is a person's name; the Actor does not filter them, so apply your own compliance rules.

**Does mobile.de Dealer Scraper need a proxy?** No. It works from standard Apify datacenter IPs and no residential traffic is billed. If you get repeated 403 errors, lower concurrency or raise the delays.

**How often should I run mobile.de Dealer Scraper?** The directory changes slowly. A monthly run is enough to track new and closed dealers; use `maxDealers` and the state filter to keep each run small.

**Can I get phone numbers, e-mails or the dealer's cars?** Not with this Actor: the directory does not publish contact data. For vehicle listings use [Mobile.de Scraper](https://apify.com/rastriq/mobile-de-scraper).

**A page failed, what now?** Failed pages are retried 5 times and counted in `SUMMARY.pagesFailed`. Re-run the affected state.

**Something broke or a field is missing?** Open an issue on the Actor page and include the run link.

# Actor input Schema

## `states` (type: `array`):

Select one or more states (Bundesländer). <b>Leave empty to crawl all 16 states.</b> Bremen is the smallest (about 130 dealers) and a good first test.

## `maxDealers` (type: `integer`):

Maximum number of dealers to return in total. You are charged per dealer ($0.002 each), so use a low value for a first test, for example <code>20</code>. <b>Set 0 for no limit</b> (about 29,000 unique dealers for all 16 states, roughly $58).

## `requestDelayMin` (type: `integer`):

Minimum pause between two page requests.

## `requestDelayMax` (type: `integer`):

Maximum pause between two page requests (random jitter between min and max).

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep it low (1-3) to stay polite with the source.

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

No proxy is needed: the dealer directory works from standard datacenter IPs and no residential traffic is billed. Only select Apify Proxy if you see repeated HTTP 403 errors.

## Actor input object example

```json
{
  "states": [
    "bremen"
  ],
  "maxDealers": 20,
  "requestDelayMin": 500,
  "requestDelayMax": 1000,
  "maxConcurrency": 1
}
```

# Actor output Schema

## `dealers` (type: `string`):

Dealer records extracted from the mobile.de directory.

## `summary` (type: `string`):

Per-state source counters, pages fetched and dealers returned.

# 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 = {
    "states": [
        "bremen"
    ],
    "maxDealers": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/mobile-de-dealers").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 = {
    "states": ["bremen"],
    "maxDealers": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/mobile-de-dealers").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 '{
  "states": [
    "bremen"
  ],
  "maxDealers": 20
}' |
apify call rastriq/mobile-de-dealers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/mobile-de-dealers"
        }
    }
}
```

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/NTLYOuimuMvUkxB9p/builds/sHfX0awbcHmm1K7XH/openapi.json