# 🚗 Kleinanzeigen Autos Scraper - German Used Cars (`benthepythondev/kleinanzeigen-autos-scraper`) Actor

Scrape used-car listings from Kleinanzeigen (Germany). Parses make, model, year, mileage, fuel, transmission, power & price into clean fields. Filter by make, location, year, mileage & price.

- **URL**: https://apify.com/benthepythondev/kleinanzeigen-autos-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** E-commerce, Other, Business
- **Stats:** 6 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.40 / 1,000 cars

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🚗 Kleinanzeigen Autos Scraper — German Used-Car Listings, Structured

Scrape **used-car listings from Kleinanzeigen** (formerly eBay Kleinanzeigen), Germany's largest classifieds site and a top source of **private-seller** vehicles — often cheaper than dealer platforms. It parses the German car attributes — **Marke (make), Modell, Erstzulassung (year), Kilometerstand (mileage), Kraftstoff (fuel), Getriebe (transmission), Leistung (power)** — into clean, structured fields. A perfect complement to dealer-focused sources like mobile.de. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🚗 What is the Kleinanzeigen Autos Scraper?

It turns any Kleinanzeigen car search into a structured dataset. Enter a **location** (a German postal code or a city name like `berlin` — auto-resolved to the right area), optionally a **make/model** keyword, and filters for price, year or mileage, then Run. The Actor walks the result pages, opens each listing to read the vehicle attributes, and returns every matching car with make, model, year, mileage, fuel, gearbox, power, condition and price. It runs through a residential German proxy by default for reliable access.

#### What data does it extract?

- **Make (Marke), model (Modell)** and **vehicle type**
- **Year** and **first registration** (Erstzulassung)
- **Mileage in km** (Kilometerstand) and **price in EUR**, plus a **price type** (fixed / negotiable / on request)
- **Fuel** (Kraftstoff), **transmission** (Getriebe) and **power** (Leistung, e.g. kW/PS)
- **Condition** (Fahrzeugzustand), **color**, **doors** and **emission class** when present
- **Title & description**, plus the full **description** from the detail page
- **City, postal code (PLZ)** and **posting date**
- **Listing URL, image URL** (and all gallery images), plus **seller name** and a **scrape timestamp**

### ⬇️ Input

Run it with simple fields, or paste exact search URLs for precise filtering:

| Field | Type | Description |
|-------|------|-------------|
| `keyword` | string | Best-effort make/model title filter, e.g. `bmw`, `vw golf`, `tesla model 3` |
| `locationCode` | string | German PLZ (e.g. `10115`) or city name (e.g. `berlin`, `münchen`); empty = all of Germany |
| `radiusKm` | integer | Search radius around the location (0–200 km) |
| `startUrls` | array | Paste exact Kleinanzeigen car-search URLs (overrides the fields above) |
| `minPrice` / `maxPrice` | integer | Price range (EUR) |
| `minYear` | integer | Min first-registration year (e.g. 2015) |
| `maxMileage` | integer | Max mileage (km) |
| `fetchDetails` | boolean | Open each listing for full specs (default true, recommended) |
| `maxResults` | integer | Maximum listings to return (1–5000, default 100) |
| `proxyConfiguration` | object | Residential DE proxy (strongly recommended — datacenter IPs are blocked) |

> **Note on the make filter:** `keyword` is a best-effort title match. Many private listings omit the brand in the title, so for precise make/model filtering, search on kleinanzeigen.de with the make facet selected and paste the resulting URL into `startUrls`.

#### Example input

```json
{
  "keyword": "bmw 3er",
  "locationCode": "münchen",
  "radiusKm": 50,
  "minYear": 2016,
  "maxPrice": 20000,
  "maxMileage": 120000,
  "maxResults": 100
}
```

### ⬆️ Output

Every car is one clean row (view as a **table**, or export **JSON / CSV / Excel**):

```json
{
  "ad_id": "2891234567",
  "title": "BMW 320d Touring, Automatik, Navi",
  "make": "BMW",
  "model": "320d",
  "year": 2017,
  "first_registration": "März 2017",
  "mileage_km": 98000,
  "price_eur": 16900,
  "price_type": "NEGOTIABLE",
  "fuel": "Diesel",
  "transmission": "Automatik",
  "power": "140 kW (190 PS)",
  "condition": "Gebraucht",
  "color": "Schwarz",
  "doors": "4/5",
  "emission_class": "Euro 6",
  "city": "München",
  "plz": "80331",
  "url": "https://www.kleinanzeigen.de/s-anzeige/...",
  "image_url": "https://img.kleinanzeigen.de/...",
  "scraped_at": "2026-06-24T09:00:00Z"
}
```

### 💡 Use cases

- **🔎 Deal-hunting & arbitrage:** spot underpriced private-seller cars before dealers do.
- **📊 Price & market analysis:** track asking prices by make, model and region over time.
- **🏷️ Dealers & resellers:** source private inventory and seller leads outside the dealer platforms.
- **🚘 Automotive apps & tools:** power a car-search product with clean, structured listings.

### ❓ FAQ

**What does it scrape?** Kleinanzeigen.de (Germany), the Autos (cars) section — predominantly private-seller listings, plus some commercial ones.

**Do I need an API key?** No. There's no login or token. A residential German proxy is configured by default for reliable access, since Kleinanzeigen blocks datacenter IPs.

**Can I search by make/model and city?** You can set `keyword` for a best-effort make/model match and `locationCode` (PLZ or city; city names auto-resolve). Because many listings omit the brand in the title, the most reliable way to filter by make is to paste a Kleinanzeigen search URL (with the make facet selected) into `startUrls`.

**What car fields do I get?** Make, model, year, first registration, mileage, price, fuel, transmission, power, condition, color, doors and emission class — whenever the listing provides them.

**Why is the make sometimes empty?** Kleinanzeigen treats car make as a structured facet that not all sellers fill in, and titles vary. The Actor parses the listing's attribute block and falls back to the title/description, but values that simply aren't present are returned as `null`.

**Should I keep "Fetch detail pages" on?** Yes for full specs — make, model, mileage, fuel and the rest live on each listing's detail page. Turning it off is faster and cheaper but returns only the basics (title, price, location, image).

**How is this different from a mobile.de scraper?** Kleinanzeigen is dominated by private sellers and budget cars — a different inventory than dealer-heavy mobile.de — which makes it ideal for arbitrage and broader market coverage.

**Can I run it on a schedule or via API?** Yes — schedule recurring runs in Apify, call it via the API/SDK, or connect it to Make, Zapier or n8n.

**Is scraping Kleinanzeigen legal?** It extracts publicly available listing data. Use it responsibly and within applicable laws and Kleinanzeigen's terms.

### Support and reviews

If a successful run gives you useful vehicle data, please leave an honest review on the [Actor review page](https://apify.com/benthepythondev/kleinanzeigen-autos-scraper/reviews). Reviews help other buyers judge the output. For missing fields, blocked searches or failed runs, open an issue on the Actor page and include the run ID and search URL so the exact case can be reproduced.

For recurring monitoring, import the free [daily Kleinanzeigen used-car alert n8n template](https://gist.github.com/benthepythondev00/e28968a940fe4195ffb5a997fe309503#file-kleinanzeigen-used-car-alerts-json). It runs this Actor on a schedule and emails a price-sorted digest without embedding an Apify token in the workflow file.

### 🔗 You might also like

- **[Kleinanzeigen Scraper](https://apify.com/benthepythondev/kleinanzeigen-scraper)** — any Kleinanzeigen category, all-purpose
- **[Kleinanzeigen Immobilien Scraper](https://apify.com/benthepythondev/kleinanzeigen-immobilien-scraper)** — German real estate listings
- **[Kleinanzeigen Jobs Scraper](https://apify.com/benthepythondev/kleinanzeigen-jobs-scraper)** — local German job ads

***

**Keywords:** Kleinanzeigen scraper, Kleinanzeigen Autos, German used car scraper, used car data Germany, car listings API, gebrauchtwagen scraper, mobile.de alternative, car price data, automotive market data, private seller cars, DACH car data, Erstzulassung Kilometerstand, vehicle data scraper.

# Actor input Schema

## `keyword` (type: `string`):

Best-effort title filter by make/model, e.g. 'bmw', 'vw golf'. Many listings omit the brand in the title, so for precise make filtering paste a Kleinanzeigen search URL (with the make facet selected) into Start URLs.

## `locationCode` (type: `string`):

German postal code (e.g. 10115) or city name (e.g. berlin, münchen) — city names are auto-resolved. Leave empty for all of Germany.

## `radiusKm` (type: `integer`):

Search radius around the location.

## `startUrls` (type: `array`):

Paste exact kleinanzeigen.de car-search URLs (overrides the fields above). Most reliable for precise filters — search on kleinanzeigen.de and copy the URL.

## `minPrice` (type: `integer`):

Only keep cars at or above this price.

## `maxPrice` (type: `integer`):

Only keep cars at or below this price.

## `minYear` (type: `integer`):

Only keep cars registered in this year or later (e.g. 2015).

## `maxMileage` (type: `integer`):

Only keep cars at or below this mileage.

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

Open each listing to extract make, model, year, mileage, fuel, gearbox, power, etc. (recommended).

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

Maximum number of listings to return.

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

Residential DE proxy is strongly recommended (Kleinanzeigen blocks datacenter IPs).

## Actor input object example

```json
{
  "keyword": "bmw",
  "locationCode": "berlin",
  "radiusKm": 0,
  "startUrls": [],
  "fetchDetails": true,
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# 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 = {
    "keyword": "bmw",
    "locationCode": "berlin",
    "startUrls": [],
    "fetchDetails": true,
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/kleinanzeigen-autos-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 = {
    "keyword": "bmw",
    "locationCode": "berlin",
    "startUrls": [],
    "fetchDetails": True,
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/kleinanzeigen-autos-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 '{
  "keyword": "bmw",
  "locationCode": "berlin",
  "startUrls": [],
  "fetchDetails": true,
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call benthepythondev/kleinanzeigen-autos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/E1LlqPPbBHSu3gb9f/builds/m8FwiwT5xaPpsI2nV/openapi.json