# Kleinanzeigen.de Car Scraper (`rastriq/kleinanzeigen-scraper`) Actor

Scrape car listings from Kleinanzeigen.de, Germany's largest classifieds site: make, model, year, mileage, price, postcode and city, photo and URL. No proxy needed, about 27 cars per page.

- **URL**: https://apify.com/rastriq/kleinanzeigen-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 car listings

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

## Kleinanzeigen.de Car Scraper

Scrape car listings from **Kleinanzeigen.de** (formerly eBay Kleinanzeigen), the largest classifieds site in Germany. Kleinanzeigen.de Car Scraper turns the *Autos* category into clean, structured data: make, model, year of first registration, mileage, asking price, postcode and city, photo and listing URL. No proxy, no login, no browser: about 27 cars per page in a few seconds.

### 🚗 What is Kleinanzeigen.de Car Scraper?

Kleinanzeigen.de Car Scraper is a Kleinanzeigen scraper and unofficial Kleinanzeigen API for the car category of the site. Kleinanzeigen is where a large part of Germany's private used car trade happens: from daily drivers and project cars to vans, classics and cars sold for parts. That makes it a useful reference for real asking prices in the German market, next to the dealer-heavy car portals.

The scraper reads the server-rendered result pages of the Autos category (`/s-autos/c216`), newest listings first, and extracts each result card. It needs no browser, so runs are fast and cheap, and it works well on a schedule to follow what has just been put up for sale.

Use it to:

- 📈 **Track used car prices** in Germany by make, model, year and mileage.
- 🔔 **Spot new listings early** with a scheduled run every hour or every day.
- 🏷️ **Benchmark your stock** against what private sellers are asking.
- 🧮 **Feed valuation models** and market research with fresh asking prices.
- 🔧 **Find project cars, classics and cars for parts** that rarely reach the big dealer portals.

### 📋 What data does Kleinanzeigen.de Car Scraper extract?

| Field | Description |
|---|---|
| 🆔 `id` | Kleinanzeigen ad ID (for example `3564471475`) |
| 📝 `title` | Listing title as written by the seller |
| 🏭 `make` | Car brand detected in the title (BMW, Audi, Opel, Mercedes...) |
| 🚘 `model` | The word that follows the make in the title (C200, Golf, Insignia...) |
| 📅 `year` | Year of first registration (from the "EZ MM/YYYY" tag) |
| 🛣️ `km` | Mileage in km |
| 💶 `price` | Asking price in EUR |
| 💱 `currency` | Always `EUR` |
| 📍 `city` | Postcode and place, for example `23743 Grömitz` |
| 🏪 `is_professional` | `true` when the card shows a business-seller badge |
| 🔗 `url` | Link to the ad page |
| 🖼️ `img_url` | First photo of the ad |
| 🕒 `scraped_at` | UTC timestamp of extraction |
| 🌐 `source` | Always `kleinanzeigen.de` |

**Be aware of what is not in the result list.** Kleinanzeigen result cards do not show engine power, fuel type or gearbox, so `hp`, `fuel_type`, `gearbox` and `region` are always `null`. They are kept so the output has the same columns as our other car marketplace scrapers. `make` and `model` are read from the free-text title, so they are a best-effort guess: a title such as "Motorschaden Ankauf Kia Sportage..." (a dealer buying damaged cars) is tagged as a Kia Sportage. In a test run of 27 listings (15 November 2026), `year`, `km` and `city` were filled on all of them, and `make`, `model` and `price` on 26.

Seller names, phone numbers and the free-text description are never read.

### 🛠️ How to use Kleinanzeigen.de Car Scraper

1. Click **Try for free** (or **Start**) on this page.
2. Keep the prefilled input (1 page) for a first test, or set how many pages you want.
3. Click **Start** and wait a few seconds per page.
4. Download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.

#### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `max_pages` | integer | 3 | Result pages of the Autos category to scrape, newest first. About 27 cars per page. |
| `proxyConfiguration` | object | no proxy | Optional proxy. Leave it off for normal runs (see Limits). |

Featured ads that Kleinanzeigen repeats at the top of later pages are saved only once per run.

#### Input example

```json
{
  "max_pages": 1
}
```

### 📦 Output example

One item from a real run (14 November 2026):

```json
{
  "id": "3564471475",
  "title": "Mercedes Benz C200",
  "make": "Mercedes",
  "model": "C200",
  "year": 2000,
  "km": 289000,
  "hp": null,
  "price": 5900,
  "currency": "EUR",
  "fuel_type": null,
  "gearbox": null,
  "city": "23743 Grömitz",
  "region": null,
  "is_professional": false,
  "url": "https://www.kleinanzeigen.de/s-anzeige/mercedes-benz-c200/3564471475-216-16671",
  "img_url": "https://img.kleinanzeigen.de/api/v1/prod-ads/images/90/90fa77ed-9967-4379-bb75-4de5cda974fa?rule=$_2.AUTO",
  "source": "kleinanzeigen.de",
  "scraped_at": "2026-11-14T07:37:55.265928+00:00"
}
```

In the Apify Console the **Overview** tab shows title, make, model, year, km, price, location and link; **All fields** adds the photo, ID and timestamps.

### 💰 How much does it cost to scrape Kleinanzeigen?

The actor uses **pay per event** pricing, with platform usage included:

- **$1.50 per 1,000 car listings** saved to the dataset;
- **$0.005 per run start** (one start event per GB of memory; the default run uses 256 MB, so one event).

A one-page test run (about 27 cars) costs about $0.045. 1,000 listings (about 37 pages) cost about $1.51. You pay only for listings that are actually saved: a run that is blocked and extracts nothing fails and only the start event is charged.

You can cap the spend of any run with the **Max total charge** option in the run settings.

### ⚠️ Limits

- **Only the general Autos category, newest first.** There are no filters for make, price or region in this version: filter the dataset after the run.
- **No details from the ad page.** The scraper reads only the result list, which is why power, fuel type, gearbox and the description are not included.
- **No proxy by default, and an IP limit on large runs.** Kleinanzeigen serves its result pages to a direct connection, so the actor runs without a proxy. The **Apify datacenter proxy gets HTTP 403**, so do not enable it. Without a proxy every request leaves from the IP of the Apify server running your job, which is shared with other users. Kleinanzeigen may rate-limit or block that IP on **large runs** (many pages, or many runs close together). If you see HTTP 403 in the log, switch `proxyConfiguration` to the **RESIDENTIAL** group with country **DE**: each page then goes through a new residential IP. Residential traffic is billed by Apify per GB, so it is slower and more expensive; keep it for runs that need it.
- **Clear failures.** If a run extracts no listings (block, HTTP error or a change in the site's layout), it ends as **FAILED** with the reason in the status message, instead of succeeding with an empty dataset.
- **Pagination depth.** Kleinanzeigen decides how many result pages it serves; asking for more pages than the site returns just ends the run early.
- The scraper sends one request every 1.5 seconds to stay polite with the site.

### 🔗 Related actors

- [Willhaben Car Scraper](https://apify.com/rastriq/willhaben-scraper): used cars from Austria.
- [Marktplaats.nl Car Scraper](https://apify.com/rastriq/marktplaats-scraper): used cars from the Netherlands.
- [2dehands Car Scraper](https://apify.com/rastriq/2dehands-scraper): used cars from Belgium.
- [Blocket Car Scraper](https://apify.com/rastriq/blocket-scraper) and [FINN.no Car Scraper](https://apify.com/rastriq/finn-no-scraper): Sweden and Norway.

All of them return the same core columns (`make`, `model`, `year`, `km`, `price`, `currency`, `url`...), so you can merge countries in one table.

### ❓ FAQ

**Is it legal to scrape Kleinanzeigen.de?**
The actor collects only public listing data that anyone can see without logging in, and it does not read seller names, phone numbers or descriptions. You are responsible for how you use the data: check Kleinanzeigen's terms and the GDPR before using it commercially.

**Do I need a proxy?**
No, not for normal runs. Leave the proxy off. Only if a large run starts getting HTTP 403, use the residential proxy with country DE. The datacenter proxy does not work on this site.

**How many listings can I get per run?**
About 27 per page. Set `max_pages` to what you need; 10 pages give about 270 listings. For large volumes, prefer several smaller scheduled runs over one very long run, because of the IP limit described above.

**Why is `price` sometimes null?**
Some ads show no number: cars given away, "price on request" or wanted ads. Negotiable prices ("VB") are kept as the number shown.

**Why are fuel type and gearbox empty?**
They are not shown in the Kleinanzeigen result list, and this actor does not open each ad page. The columns stay in the output for compatibility with our other car scrapers.

**Can I filter by make or model?**
Not in the input yet. Every listing has `make` and `model`, so you can filter in the dataset view, in Excel or in your own code.

**How fresh is the data?**
Each run reads the live site. Listings come newest first, so a short scheduled run (1–3 pages) every hour catches most new cars.

**The run failed. What now?**
Read the status message: it says why no listings were extracted. HTTP 403 means a block (try the residential DE proxy); "no ads were parsed" usually means the site changed its layout. Open an issue on the actor page and we will look at it.

# Changelog

This Actor's version history is a separate document: https://apify.com/rastriq/kleinanzeigen-scraper/changelog.md

# Actor input Schema

## `max_pages` (type: `integer`):

Enter how many result pages of the Autos category to scrape, newest listings first. Each page returns about <b>27 cars</b>, so 10 pages ≈ 270 listings. Start with 1 page for a test run. Featured ads that repeat on later pages are saved only once.

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

Optional. Without a proxy the scraper connects directly. <b>Do not use the Apify datacenter proxy</b>: Kleinanzeigen answers it with HTTP 403. If a large run gets HTTP 403 without a proxy, switch to the <b>RESIDENTIAL</b> group with country <b>DE</b>; each page then goes through a new residential IP (residential traffic is billed by Apify per GB).

## Actor input object example

```json
{
  "max_pages": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped 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 = {
    "max_pages": 1,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/kleinanzeigen-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 = {
    "max_pages": 1,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/kleinanzeigen-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 '{
  "max_pages": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rastriq/kleinanzeigen-scraper --silent --output-dataset

```

## MCP server setup

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