# Kleinanzeigen Jobs Scraper - German Local Job Ads (`benthepythondev/kleinanzeigen-jobs-scraper`) Actor

Scrape job listings (Stellenangebote) from Kleinanzeigen (Germany). Parses title, employment type, salary, company, city & posting date into clean fields. Captures local / SME / mini-job inventory missing from corporate ATS boards. Filter by role, location & employment type.

- **URL**: https://apify.com/benthepythondev/kleinanzeigen-jobs-scraper.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Jobs Scraper — German Local Job Ads

Scrape **job listings (Stellenangebote) from Kleinanzeigen** (formerly eBay
Kleinanzeigen), Germany's largest classifieds site and a huge source of **local,
SME and mini-job** vacancies. It parses each ad into clean, structured fields —
**title, employment type (Art der Anstellung), salary, company, city, PLZ and
posting date** — capturing inventory that never appears on corporate ATS boards
like Greenhouse, Lever or Ashby.

### Quick start

Enter a **job role** (e.g. `pflegekraft`, `fahrer`, `aushilfe`), a **location**
(PLZ or city like `berlin` — city names are auto-resolved), and click Run. You'll
get structured job listings with employment type, salary (when stated), company and
location. Leave the role empty to pull every job in the area.

### Why this Actor

- **Hidden local inventory** — Kleinanzeigen is where small businesses, shops,
  restaurants, care services and private employers post directly; these jobs are
  absent from corporate job boards and aggregators.
- **Structured job data** — title, employment type, salary + period, company, city,
  PLZ, posting date — not just a blob of text.
- **Filter where it matters** — role/keyword, location + radius, employment type
  (Vollzeit / Teilzeit / Minijob).
- **Reliable access** — residential DE proxies + city→ID resolution, the same
  hardened engine behind our Kleinanzeigen real-estate and autos scrapers.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `keyword` | string | Job role, e.g. "pflegekraft", "fahrer", "aushilfe küche" |
| `locationCode` | string | PLZ (10115) or city name (berlin, münchen) |
| `radiusKm` | integer | Search radius |
| `employmentType` | string | Keep only "Vollzeit", "Teilzeit", "Minijob", … |
| `startUrls` | array | Paste exact Kleinanzeigen jobs-search URLs (precise control) |
| `fetchDetails` | boolean | Open each listing for full text + company (default true) |
| `maxResults` | integer | Max listings to return |

#### Example input

```json
{
  "keyword": "fahrer",
  "locationCode": "münchen",
  "radiusKm": 20,
  "employmentType": "Vollzeit",
  "maxResults": 100
}
````

### Output

```json
{
  "ad_id": "2891234567",
  "title": "LKW Fahrer (m/w/d) in Vollzeit gesucht",
  "job_category": "Fahrer/-in",
  "employment_type": "Vollzeit",
  "salary_eur": 2800,
  "salary_period": "month",
  "experience": "Mit Berufserfahrung",
  "company": "Spedition Müller GmbH",
  "city": "München",
  "plz": "80331",
  "posted_date": "23.06.2026",
  "url": "https://www.kleinanzeigen.de/s-anzeige/...",
  "full_description": "Wir suchen ab sofort ...",
  "scraped_at": "2026-06-24T09:00:00Z"
}
```

### Use cases

- **Recruiting & sourcing** — find local hires and employers outside the big boards.
- **Labour-market analysis** — track local demand, wages and employment types by region.
- **Job-board aggregation** — enrich your board with hyper-local German listings.
- **Lead generation** — small employers actively hiring are strong B2B leads.

### FAQ

**What does it scrape?** Kleinanzeigen.de (Germany), the Jobs (Stellenangebote) section — local and SME job ads.

**Do I need an API key?** No. A residential DE proxy is used automatically for reliable access.

**Can I search by role and city?** Yes — set `keyword` (the role) and `locationCode` (PLZ or city; city names auto-resolve to the right area). For full control, paste a search URL in `startUrls`.

**What fields do I get?** Title, job category, employment type (Vollzeit/Teilzeit/Minijob), salary + period (when stated), experience level, company, city, PLZ, posting date, full description, and the listing URL.

**How is this different from an ATS / job-board scraper?** Corporate boards (Greenhouse, Lever, Ashby) only carry mid/large-company tech & office roles. Kleinanzeigen carries local, hourly, trade, care, hospitality and mini-jobs — a completely different, hyper-local inventory.

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

***

**Keywords:** Kleinanzeigen scraper, Kleinanzeigen Jobs, German job scraper, Stellenangebote scraper, German job listings API, local jobs Germany, job data Germany, recruiting data, labour market data, mini job scraper, DACH job data, Teilzeit Vollzeit Minijob.

# Actor input Schema

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

Filter listings whose title contains this role, e.g. 'pflegekraft', 'fahrer', 'aushilfe küche'. Job titles reliably contain the role, so this works well. Leave empty to get all jobs in the location.

## `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 jobs-search URLs (overrides the fields above). Most reliable for precise sub-category filters — search on kleinanzeigen.de and copy the URL.

## `employmentType` (type: `string`):

Keep only jobs whose 'Art der Anstellung' contains this text, e.g. 'Vollzeit', 'Teilzeit', 'Minijob'. Leave empty for all.

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

Open each listing to extract the full description, employment type, salary and company (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
{
  "locationCode": "berlin",
  "radiusKm": 0,
  "fetchDetails": true,
  "maxResults": 100,
  "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 = {
    "locationCode": "berlin",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kleinanzeigen Jobs Scraper - German Local Job Ads",
        "description": "Scrape job listings (Stellenangebote) from Kleinanzeigen (Germany). Parses title, employment type, salary, company, city & posting date into clean fields. Captures local / SME / mini-job inventory missing from corporate ATS boards. Filter by role, location & employment type.",
        "version": "0.1",
        "x-build-id": "P6hYPuSVORnw0iDdL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~kleinanzeigen-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-kleinanzeigen-jobs-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/benthepythondev~kleinanzeigen-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-kleinanzeigen-jobs-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/benthepythondev~kleinanzeigen-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-kleinanzeigen-jobs-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": {
                    "keyword": {
                        "title": "Job role / keyword (optional)",
                        "type": "string",
                        "description": "Filter listings whose title contains this role, e.g. 'pflegekraft', 'fahrer', 'aushilfe küche'. Job titles reliably contain the role, so this works well. Leave empty to get all jobs in the location."
                    },
                    "locationCode": {
                        "title": "Location (PLZ or city)",
                        "type": "string",
                        "description": "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": {
                        "title": "Radius (km)",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Search radius around the location.",
                        "default": 0
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Paste exact kleinanzeigen.de jobs-search URLs (overrides the fields above). Most reliable for precise sub-category filters — search on kleinanzeigen.de and copy the URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "employmentType": {
                        "title": "Employment type (optional)",
                        "type": "string",
                        "description": "Keep only jobs whose 'Art der Anstellung' contains this text, e.g. 'Vollzeit', 'Teilzeit', 'Minijob'. Leave empty for all."
                    },
                    "fetchDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Open each listing to extract the full description, employment type, salary and company (recommended).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential DE proxy is strongly recommended (Kleinanzeigen blocks datacenter IPs).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "DE"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
