# Kleinanzeigen Scraper (`automation-lab/kleinanzeigen-scraper`) Actor

Scrape Kleinanzeigen.de listings -- electronics, furniture, cars, apartments, jobs. Get titles, prices, descriptions, locations, seller info, images, and listing details. Pure HTTP, no browser needed.

- **URL**: https://apify.com/automation-lab/kleinanzeigen-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Real estate, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Scraper

### What does Kleinanzeigen Scraper do?

**Kleinanzeigen Scraper** extracts structured listing data from [Kleinanzeigen.de](https://www.kleinanzeigen.de) (formerly eBay Kleinanzeigen) -- **Germany's largest classifieds marketplace** with millions of active listings. Enter search keywords and get detailed data: titles, prices, descriptions, locations, seller info, images, categories, and listing attributes.

The scraper uses **pure HTTP requests** (no browser) so it runs fast and cheap. It handles pagination automatically, supports location and price filters, and can optionally visit each listing's detail page for complete data including full descriptions, all images, seller profiles, and item attributes.

Try it right now -- click **Start** with the prefilled input to scrape bicycle listings from Berlin.

### Who is Kleinanzeigen Scraper for?

- **Market researchers** -- Track pricing trends for used electronics, cars, furniture, or real estate across German cities. Monitor supply and demand in specific categories.
- **E-commerce sellers** -- Research competitor pricing on secondhand goods. Find underpriced items for resale. Analyze what sells fastest in your niche.
- **Real estate professionals** -- Monitor apartment and house listings across German cities. Track rental and sale prices by neighborhood.
- **Data analysts** -- Build datasets of classifieds listings for academic research, price index calculations, or consumer behavior studies.
- **Recruiters & HR teams** -- Monitor job postings in specific German cities to understand local hiring trends and salary ranges.

### Why use Kleinanzeigen Scraper?

- **No login or API key required** -- scrapes publicly available listing data
- **Pure HTTP scraper** -- no browser overhead, runs 10x faster than Playwright-based alternatives
- **Extremely low cost** -- HTTP-only means minimal compute usage, no expensive proxy needed
- **Automatic pagination** -- fetches as many pages as needed to reach your target count
- **Detail page enrichment** -- optionally visit each listing for full descriptions, all images, and seller profiles
- **Location & price filters** -- narrow results to specific cities and price ranges
- **German market specialist** -- handles German number formatting (1.999 EUR), VB (Verhandlungsbasis) negotiable prices, and German-language categories
- **Structured JSON output** -- export to JSON, CSV, Excel, or connect via API
- **Scheduled runs** -- set up recurring scrapes to monitor new listings daily
- **Apify platform integration** -- connect with 5,000+ apps via Zapier, Make, and webhooks

### What data can you extract?

| Field | Description | Available in |
|-------|-------------|-------------|
| `title` | Listing title | Search + Detail |
| `price` | Price as displayed (e.g., "350 EUR VB") | Search + Detail |
| `priceNumeric` | Parsed numeric price in EUR | Search + Detail |
| `isNegotiable` | Whether the price is negotiable (VB) | Search + Detail |
| `location` | City/district with postal code | Search + Detail |
| `postedDate` | Date the listing was posted | Detail only |
| `category` | Category breadcrumbs (e.g., "Elektronik > Notebooks") | Detail only |
| `url` | Direct link to the listing | Search + Detail |
| `thumbnailUrl` | Listing thumbnail image URL | Search + Detail |
| `description` | Full listing description text | Detail only (snippet in search) |
| `sellerName` | Seller's display name | Detail only |
| `sellerType` | "private" or "commercial" | Detail only |
| `sellerUrl` | Link to seller's profile | Detail only |
| `imageCount` | Number of photos | Search + Detail |
| `imageUrls` | Array of all image URLs | Detail only |
| `attributes` | Listing-specific attributes (Art, Zustand, etc.) | Detail only |
| `breadcrumbs` | Full category path | Detail only |
| `listingId` | Unique Kleinanzeigen ad ID | Search + Detail |
| `scrapedAt` | Timestamp when the data was collected | Search + Detail |

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

Kleinanzeigen Scraper uses **pay-per-event** pricing -- you only pay for what you scrape.

| Event | Price | Description |
|-------|-------|-------------|
| Actor start | $0.001 | One-time charge per run |
| Listing (search only) | $0.001 | Each listing from search results |
| Listing (with details) | $0.003 | Each listing with full detail page data |

**Example costs:**
- 100 listings from search results: ~$0.10
- 100 listings with full details: ~$0.30
- 500 listings from search results: ~$0.50
- 1,000 listings with full details: ~$3.00

With Apify's **free plan** ($5 monthly credits), you can scrape approximately **5,000 basic listings** or **1,600 detailed listings** per month at no cost.

### How to scrape Kleinanzeigen listings

1. Go to [Kleinanzeigen Scraper](https://apify.com/automation-lab/kleinanzeigen-scraper) on Apify Store.
2. Click **Try for free** to open the actor in Apify Console.
3. Enter your search keywords (e.g., "laptop", "wohnung berlin", "bmw 3er").
4. Optionally set a location filter (e.g., "hamburg", "muenchen").
5. Set the maximum number of results and whether to include full details.
6. Click **Start** and wait for the run to finish.
7. Download your data as JSON, CSV, or Excel from the **Dataset** tab.

**Example input for laptop listings in Berlin under 500 EUR:**
```json
{
    "searchQueries": ["laptop"],
    "location": "berlin",
    "maxPrice": 500,
    "maxResults": 50,
    "includeDetails": true
}
````

**Example input for multiple searches:**

```json
{
    "searchQueries": ["iphone 15", "samsung galaxy s24", "pixel 8"],
    "maxResults": 30,
    "includeDetails": false
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | -- | Keywords to search on Kleinanzeigen.de |
| `listingUrls` | string\[] | -- | Direct URLs to listing or search pages |
| `location` | string | -- | City/region filter (e.g., "berlin", "hamburg") |
| `categoryId` | string | -- | Category ID filter (e.g., "c176" for electronics) |
| `minPrice` | integer | -- | Minimum price in EUR |
| `maxPrice` | integer | -- | Maximum price in EUR |
| `maxResults` | integer | 100 | Maximum listings per search keyword |
| `includeDetails` | boolean | false | Visit each listing for full details |
| `maxRequestRetries` | integer | 3 | Retry count for failed requests |

### Output examples

**Basic listing (search only):**

```json
{
    "listingId": "3372759636",
    "title": "Van Rysel NCR CF Allroad | SRAM Apex AXS | Carbon",
    "price": "1.999 EUR VB",
    "priceNumeric": 1999,
    "isNegotiable": true,
    "location": "10961 Kreuzberg",
    "url": "https://www.kleinanzeigen.de/s-anzeige/...",
    "thumbnailUrl": "https://img.kleinanzeigen.de/...",
    "imageCount": 4,
    "scrapedAt": "2026-04-09T02:27:51.594Z"
}
```

**Detailed listing (with `includeDetails: true`):**

```json
{
    "listingId": "3354525614",
    "title": "HP EliteBook 840 G7 i7-10610U 16GB DDR4 256GB NVMe SSD",
    "price": "VB",
    "priceNumeric": null,
    "isNegotiable": true,
    "location": "20537 Hamburg-Mitte - Hamburg Hamm",
    "postedDate": "16.03.2026",
    "category": "Elektronik > Notebooks",
    "description": "HP EliteBook 840 G7 -- i7-10610U -- 14\" FHD...",
    "sellerName": "Notebook-Pro",
    "sellerType": "commercial",
    "imageCount": 14,
    "imageUrls": ["https://img.kleinanzeigen.de/..."],
    "attributes": {},
    "breadcrumbs": ["Kleinanzeigen Hamburg", "Elektronik", "Notebooks"],
    "scrapedAt": "2026-04-09T02:31:54.621Z"
}
```

### Tips for best results

- **Start small** -- begin with `maxResults: 25` and `includeDetails: false` to verify your search returns what you expect. Scale up once confirmed.
- **Use location filters** -- Kleinanzeigen results are much more relevant when filtered by city. Add the city name to your search query or use the `location` parameter.
- **Enable details selectively** -- `includeDetails: true` visits each listing page individually, which is slower and costs more. Use it when you need full descriptions, all images, or seller info.
- **Price filters save time** -- use `minPrice` and `maxPrice` to skip irrelevant listings rather than filtering after scraping.
- **Schedule weekly runs** -- set up recurring runs to track new listings in your niche. Combine with Google Sheets integration to build a living database.
- **German keywords work best** -- search in German for more accurate results (e.g., "Wohnung" instead of "apartment").
- **Multiple searches in one run** -- add multiple keywords to `searchQueries` to scrape different categories in a single run. Each keyword runs a separate search.

### Integrations

- **Kleinanzeigen Scraper + Google Sheets** -- automatically export new listings to a spreadsheet. Track pricing trends for used cars, electronics, or furniture over time.
- **Kleinanzeigen Scraper + Slack/Discord** -- get notified when new listings match your criteria. Set up alerts for specific keywords or price ranges.
- **Kleinanzeigen Scraper + Make/Zapier** -- build automated workflows: scrape listings, filter by price, send to your CRM, or post to your inventory system.
- **Scheduled monitoring** -- run the scraper daily or weekly to catch new listings before competitors. Combine with webhooks for real-time processing.
- **Kleinanzeigen Scraper + Airtable** -- build a searchable database of listings with images, prices, and seller contacts for your team.

### Using the Apify API

You can run Kleinanzeigen Scraper programmatically using the Apify API.

**Node.js:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/kleinanzeigen-scraper').call({
    searchQueries: ['laptop berlin'],
    maxResults: 50,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('automation-lab/kleinanzeigen-scraper').call(run_input={
    'searchQueries': ['laptop berlin'],
    'maxResults': 50,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL:**

```bash
curl "https://api.apify.com/v2/acts/automation-lab~kleinanzeigen-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "searchQueries": ["laptop berlin"],
    "maxResults": 50,
    "includeDetails": true
  }'
```

### Use with AI agents via MCP

Kleinanzeigen Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client -- this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/kleinanzeigen-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com?tools=automation-lab/kleinanzeigen-scraper"
        }
    }
}
```

#### Example prompts

- "Find the cheapest bicycles listed in Berlin on Kleinanzeigen under 200 EUR"
- "Scrape laptop listings from Kleinanzeigen in Hamburg and show me the average price"
- "Get all apartment listings in Munich from Kleinanzeigen with full details and seller info"

### Is it legal to scrape Kleinanzeigen?

Kleinanzeigen Scraper collects only **publicly available data** that anyone can access by visiting Kleinanzeigen.de in a web browser. The scraper does not bypass any login walls, CAPTCHAs, or access restrictions.

Web scraping of public data is generally considered legal in the EU and Germany, subject to compliance with GDPR and the website's terms of service. When using this scraper:

- Only collect data you have a legitimate purpose for
- Do not scrape personal data (emails, phone numbers) without a legal basis under GDPR
- Respect rate limits and do not overload the website
- Review Kleinanzeigen's terms of service for your specific use case

For more information, see Apify's guide on [web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**How fast is Kleinanzeigen Scraper?**
Very fast. Since it uses pure HTTP requests (no browser), it can scrape ~25 listings per second from search results. With detail page enrichment enabled, speed depends on network latency but typically processes 5 listings per second.

**How much does it cost to scrape 1,000 listings?**
Without details: approximately $1.00. With full details: approximately $3.00. The free Apify plan ($5/month) covers thousands of listings.

**Why are some fields empty in search-only mode?**
Fields like `description`, `sellerName`, `sellerType`, `postedDate`, `attributes`, and full `imageUrls` are only available when `includeDetails` is enabled. Search results provide a subset of data (title, price, location, thumbnail).

**Why do some listings show `priceNumeric: null`?**
Some listings on Kleinanzeigen have no fixed price -- they show only "VB" (Verhandlungsbasis, meaning "negotiable"). In these cases, `priceNumeric` is null but `isNegotiable` is true.

**Can I scrape listings in a specific category?**
Yes. Use the `categoryId` parameter with the Kleinanzeigen category code (e.g., "c176" for electronics, "c86" for cars, "c210" for furniture). You can find category IDs in the Kleinanzeigen URL when browsing categories.

**Why are results empty for my search?**
Check that your search keywords are in German. Kleinanzeigen is a German-language platform, so English keywords may return no results. Also verify the location name uses the German spelling (e.g., "muenchen" not "munich").

### Other classifieds scrapers

- [Craigslist Scraper](https://apify.com/automation-lab/craigslist-scraper) -- scrape US classifieds listings from Craigslist
- [Vinted Scraper](https://apify.com/automation-lab/vinted-scraper) -- scrape secondhand fashion listings from Vinted
- [Allegro Scraper](https://apify.com/automation-lab/allegro-scraper) -- scrape product listings from Poland's largest marketplace
- [AutoScout24 Scraper](https://apify.com/automation-lab/autoscout24-scraper) -- scrape car listings from AutoScout24
- [Booking Scraper](https://apify.com/automation-lab/booking-scraper) -- scrape hotel and accommodation listings from Booking.com

# Actor input Schema

## `searchQueries` (type: `array`):

List of keywords to search on Kleinanzeigen.de. Each keyword runs a separate search.

## `listingUrls` (type: `array`):

Direct URLs to Kleinanzeigen listing pages or search result pages. Use this instead of keywords for specific listings.

## `location` (type: `string`):

City or region to filter results. Examples: berlin, muenchen, hamburg, koeln. Leave empty for all of Germany.

## `categoryId` (type: `string`):

Kleinanzeigen category ID to filter results. Examples: c176 (electronics), c86 (cars), c210 (furniture). Leave empty for all categories.

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

Minimum price filter in euros. Leave empty for no minimum.

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

Maximum price filter in euros. Leave empty for no maximum.

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

Maximum number of listings to return per keyword. Each page has ~25 listings.

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

Visit each listing page to get full description, all images, seller info, and listing attributes. Slower but more data.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed HTTP requests.

## Actor input object example

```json
{
  "searchQueries": [
    "fahrrad berlin"
  ],
  "listingUrls": [],
  "maxResults": 25,
  "includeDetails": false,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "fahrrad berlin"
    ],
    "listingUrls": [],
    "location": "",
    "categoryId": "",
    "maxResults": 25,
    "includeDetails": false,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "searchQueries": ["fahrrad berlin"],
    "listingUrls": [],
    "location": "",
    "categoryId": "",
    "maxResults": 25,
    "includeDetails": False,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/kleinanzeigen-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 '{
  "searchQueries": [
    "fahrrad berlin"
  ],
  "listingUrls": [],
  "location": "",
  "categoryId": "",
  "maxResults": 25,
  "includeDetails": false,
  "maxRequestRetries": 3
}' |
apify call automation-lab/kleinanzeigen-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kleinanzeigen Scraper",
        "description": "Scrape Kleinanzeigen.de listings -- electronics, furniture, cars, apartments, jobs. Get titles, prices, descriptions, locations, seller info, images, and listing details. Pure HTTP, no browser needed.",
        "version": "0.1",
        "x-build-id": "cKCOj70oX7EP1Jm3p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~kleinanzeigen-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-kleinanzeigen-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~kleinanzeigen-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-kleinanzeigen-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~kleinanzeigen-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-kleinanzeigen-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "List of keywords to search on Kleinanzeigen.de. Each keyword runs a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "Listing URLs",
                        "type": "array",
                        "description": "Direct URLs to Kleinanzeigen listing pages or search result pages. Use this instead of keywords for specific listings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "City or region to filter results. Examples: berlin, muenchen, hamburg, koeln. Leave empty for all of Germany."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Kleinanzeigen category ID to filter results. Examples: c176 (electronics), c86 (cars), c210 (furniture). Leave empty for all categories."
                    },
                    "minPrice": {
                        "title": "Minimum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter in euros. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter in euros. Leave empty for no maximum."
                    },
                    "maxResults": {
                        "title": "Max listings per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to return per keyword. Each page has ~25 listings.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include full listing details",
                        "type": "boolean",
                        "description": "Visit each listing page to get full description, all images, seller info, and listing attributes. Slower but more data.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed HTTP requests.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
