# Kleinanzeigen Listings Scraper (`neuro-scraper/kleinanzeigen-listings-scraper`) Actor

Kleinanzeigen Scraper SD - Kleinanzeigen Scraper is a classifieds data tool that extracts kleinanzeigen.de ads by keyword or browser URL: title, price, VB and free flags, location, date, images, seller type and shop, page after page, plus optional full ad details.

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

## Pricing

from $2.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper — kleinanzeigen.de ads by keyword or URL

Kleinanzeigen Scraper turns kleinanzeigen.de search results into a clean table: title, price (number, VB and free flags), location, date, images, seller type and shop, page after page. Type a search term, or paste any search, category or filtered result URL from your browser (location, radius, category, price and sort are kept). Turn on **ad details** to also get the full description, attributes, features, coordinates and the seller's public profile.

No account, no login, no browser: it reads the same public pages a logged-out visitor sees. Phone numbers, messages and seller contact details need a Kleinanzeigen login and are **not** collected.

#### Input

| Field | Type | Default | Meaning |
|---|---|---|---|
| `searchTerms` | array | `["fahrrad"]` (prefill) | Search terms, one per line, all of Germany |
| `startUrls` | array | empty | Result URLs copied from the browser (e.g. `https://www.kleinanzeigen.de/s-fahrraeder/berlin/fahrrad/k0c217l3331r10`) and single ad URLs (`/s-anzeige/...`) |
| `maxItems` | integer | `20` | Total ads to return; pages are read until this is reached |
| `maxPagesPerSearch` | integer 1–50 | `50` | Safety limit on result pages per search term or URL |
| `sortBy` | select | `newest` | `newest`, `priceAsc`, `priceDesc` — for the search terms |
| `minPrice` / `maxPrice` | integer | empty | Price range in EUR — for the search terms |
| `includeTopAds` | boolean | `true` | Keep the ~2 paid "top ads" shown at the head of every result page |
| `includeDetails` | boolean | `false` | Open every ad page for the detail fields (+1 request per ad) |
| `includeViewCount` | boolean | `false` | With details: also read the ad's view counter (+1 request per ad; counts as one visit, like a browser) |
| `proxyConfiguration` | proxy | Apify RESIDENTIAL, Germany | Proxy for kleinanzeigen.de |

Start URLs keep their own filters; `sortBy` / `minPrice` / `maxPrice` apply to the search terms. An ad found by several inputs is returned once.

#### Output

| Field | Meaning |
|---|---|
| `adId`, `url`, `title` | Ad id, canonical ad URL, title |
| `price`, `currency`, `priceText` | Price as a number (`EUR`) and as shown ("350 € VB"); "Zu verschenken" gives `price` 0 |
| `isNegotiable`, `isFree` | "VB" (Verhandlungsbasis) and "Zu verschenken" flags |
| `location`, `postalCode`, `city` | "24351 Thumby" as shown; `city` is the place name the site shows (a town, or a district in big cities) |
| `date`, `dateText` | Date shown on the listing, ISO (`2026-10-02T21:57:00+02:00` for "Heute, 21:57", `2026-09-18` for older ads) and raw |
| `description` | Snippet from the result page (up to 250 characters); full text with details |
| `imageUrl`, `imageCount`, `images` | First image, number of images, all image URLs |
| `shipping`, `buyNow` | "Versand möglich" / "Nur Abholung" / "+ Versand ab 0,99 €"; "Direkt kaufen" available |
| `isTopAd` | Paid top ad (moved to the top, often older) |
| `sellerType`, `sellerId`, `storeName`, `storeUrl` | `private` / `commercial`, seller id, PRO shop name and page |
| `tags` | Chips on the result card: "Direkt kaufen", "Gesuch", "49 m²", "2 Zi.", "Online-Besichtigung" (search rows) |
| `distanceKm` | Distance from the searched place (only for URLs with a location and radius) |
| `position`, `page`, `searchTerm` / `inputUrl`, `searchUrl` | Where the ad was found and which input produced it |
| `isWanted`, `region`, `latitude`, `longitude` | Details: wanted ad ("Gesuch"), federal state, map position |
| `categoryId`, `category`, `attributes`, `features` | Details: "Auto, Rad & Boot > Fahrräder & Zubehör", `{"Zustand": "Sehr Gut", "Wohnfläche": "49 m²"}`, `["Balkon", "Einbauküche"]` |
| `createdDate`, `sellerName`, `sellerSince`, `sellerBadges`, `sellerActiveAds` | Details: creation date (when the page shows it), public seller profile |
| `viewCount` | Details + `includeViewCount`: views of the ad |
| `scrapedAt` | ISO timestamp (UTC) |

#### Measured limits (2026-10-02/03, from one residential IP)

- Kleinanzeigen shows 25 regular ads per page plus about 2 top ads, and at most **50 pages (1,250 regular ads) per search** — page 51 redirects back to page 50. Narrow by category, location or price for more.
- Speed: 80 ads over 4 pages in 7 s; 54 ads over 2 pages in 3 s. With details about 1–1.3 s per ad (5 ads with details in 10 s).
- With "Newest" sorting, new ads keep arriving at the top (about 25 "fahrrad" ads in 3 minutes), so pages read minutes apart can repeat ads; duplicates are removed, at ~1 request per second we measured none.
- `createdDate` is missing on the first ad page of each session (the site serves an older page layout first); `buyNow` can be empty on that layout too.
- Not collected: phone numbers, messages, seller contact, commercial sellers' legal imprint.

#### Example input

```json
{"startUrls": ["https://www.kleinanzeigen.de/s-wohnung-mieten/berlin/sortierung:neuste/c203l3331"], "searchTerms": ["e bike"], "sortBy": "priceAsc", "minPrice": 200, "maxPrice": 900, "includeDetails": true, "maxItems": 100}
```

# Actor input Schema

## `searchTerms` (type: `array`):

What you would type in the Kleinanzeigen search box, one term per line. Searches all of Germany. Example: fahrrad

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

Search, category or filtered result URLs copied from the browser (location, radius, category, price and sort are kept), e.g. https://www.kleinanzeigen.de/s-fahrraeder/berlin/fahrrad/k0c217l3331r10 - and single ad URLs (.../s-anzeige/<title>/<id>-<cat>-<loc>), which return that ad with all details.

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

Maximum number of ads to return in total. Result pages are read one after another until this number is reached or the search has no further page. Example: 100

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

Safety limit on result pages per search term or URL. Kleinanzeigen itself shows at most 50 pages (about 1,250 ads) per search - narrow the search by category, location or price for more. Example: 10

## `sortBy` (type: `string`):

Order of the results for the search terms above (start URLs keep the sort they carry).

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

Only ads from this price, for the search terms above. Example: 100

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

Only ads up to this price, for the search terms above. Example: 500

## `includeTopAds` (type: `boolean`):

Kleinanzeigen shows about 2 paid "top ads" at the head of every result page; they are older ads moved to the top. Turn off to keep only the regular results (each row has isTopAd either way).

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

Open every ad page and add the full description, attributes (e.g. Zustand, Wohnfläche), features, category, region and coordinates, creation date and the seller's public profile (name, since, badges, active ads). Costs 1 extra request per ad, so runs are slower.

## `includeViewCount` (type: `boolean`):

With ad details on: also read the ad's view counter (1 more request per ad - the same counter call the ad page makes in a browser, so it counts as one visit).

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

Residential proxy in Germany is recommended for larger runs (Kleinanzeigen uses Akamai bot protection) and is the default.

## Actor input object example

```json
{
  "searchTerms": [
    "fahrrad"
  ],
  "startUrls": [],
  "maxItems": 20,
  "maxPagesPerSearch": 50,
  "sortBy": "newest",
  "includeTopAds": true,
  "includeDetails": false,
  "includeViewCount": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# 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 = {
    "searchTerms": [
        "fahrrad"
    ],
    "startUrls": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("neuro-scraper/kleinanzeigen-listings-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 = {
    "searchTerms": ["fahrrad"],
    "startUrls": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("neuro-scraper/kleinanzeigen-listings-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 '{
  "searchTerms": [
    "fahrrad"
  ],
  "startUrls": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call neuro-scraper/kleinanzeigen-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neuro-scraper/kleinanzeigen-listings-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/JnnFUanLgjc4LcVhb/builds/Kfek3oK0RgOptHgS1/openapi.json