# Arbeitsagentur Jobs Scraper (`zilicon/german-jobs-scraper`) Actor

Scrape German job listings and get title, employer, occupation, location, postcode, contract type, working time, remote flag, start date and apply URL. Filter by city and radius, sector, employer or posting age. No login, no account.

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

## Pricing

$3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

### Scrape the German job market from the Arbeitsagentur job board

Pull structured job listings from the **Bundesagentur für Arbeit (Arbeitsagentur)** - the German Federal Employment Agency and the country's largest job board, covering the whole German market rather than one city or one sector.

Every run returns clean, flat JSON: job title, employer, occupation, location and postcode, contract type, working-time model, remote flag, start date, first-published date and a link straight to the posting. No login, no account, no cookies.

**Get your first results in about 30 seconds:** press **Start** with the prefilled input. It returns 100 developer jobs from across Germany. Then change **Search keywords** to your own term, set a **Location** and a **Search radius**, and run it again.

Your **$5 of free Apify credit is worth roughly 1,670 job records** on this actor.

#### What you get per job

| Field | Description |
|---|---|
| `id` | Stable id, source-prefixed - e.g. `arbeitsagentur:13644-310253-S` |
| `board` | Always `arbeitsagentur` |
| `title` | Job title as advertised |
| `company` | Hiring employer |
| `location` | City, region, country, with consecutive repeats collapsed - e.g. `Berlin, DEUTSCHLAND` |
| `postalCode` | German postcode of the workplace |
| `category` | Main occupation (Hauptberuf) - e.g. `Anwendungsprogrammierer/in` |
| `tags` | All occupations the posting is classified under |
| `offerType` | `ARBEIT` (job), `AUSBILDUNG` (apprenticeship), and similar |
| `remote` | `true` when the employer flagged the role as home-office capable |
| `fullTime` / `partTime` | Working-time model flags |
| `contractDuration` | Permanent, fixed-term, or not stated |
| `startDate` | Earliest start date, when the employer gave one |
| `distanceKm` | Distance from your search location, when you set one |
| `salaryMin`, `salaryMax` | Reserved - the agency's search feed publishes no salary figure |
| `url`, `applyUrl` | The employer's own posting when available, otherwise the Arbeitsagentur detail page |
| `publishedAt` | ISO 8601 date the posting first appeared |
| `teaser` | Reserved - the long description lives on the detail page, not the search feed |

#### Sample record

```json
{
  "id": "arbeitsagentur:13644-310253-S",
  "board": "arbeitsagentur",
  "title": "Fullstack Developer (m/w/d)",
  "company": "secunet",
  "location": "Berlin, DEUTSCHLAND",
  "postalCode": "10178",
  "category": "Anwendungsprogrammierer/in",
  "tags": ["Anwendungsprogrammierer/in"],
  "offerType": "ARBEIT",
  "remote": true,
  "fullTime": false,
  "partTime": false,
  "contractDuration": "KEINE_ANGABE",
  "startDate": "2026-08-01",
  "distanceKm": 2,
  "salaryMin": null,
  "salaryMax": null,
  "url": "https://www.get-in-it.de/jobsuche/p310253?utm_source=arbeitsagentur&utm_medium=organic&utm_campaign=launch-basic",
  "applyUrl": "https://www.get-in-it.de/jobsuche/p310253?utm_source=arbeitsagentur&utm_medium=organic&utm_campaign=launch-basic",
  "publishedAt": "2026-08-01T00:00:00.000Z",
  "teaser": null
}
```

### Filters

Everything below is applied by the job board itself, so you pay only for the rows you actually asked for. The one exception is **Remote-capable only**, which is applied to the results after fetching - see the note under it.

| Input | What it does |
|---|---|
| `keywords` | Free-text job search, e.g. `developer`, `projektmanager`, `pflegefachkraft`. Blank returns everything matching your other filters |
| `maxResults` | Stop after this many jobs. Your cost control |
| `location` | City or postcode to search around, e.g. `Berlin`, `München`, `10178` |
| `radiusKm` | How far around that location to search - 25 for a city, 200 for a region |
| `occupationField` | One of the agency's occupational groups, e.g. `Softwareentwicklung und Programmierung`, `Altenpflege` |
| `employer` | Only this employer, using its full registered name, e.g. `Deutsche Bahn AG`, `Siemens AG` |
| `publishedWithinDays` | Only postings from the last N days, 1 to 100 |
| `offerType` | Job, apprenticeship / dual study, internship, or self-employment |
| `contractType` | Permanent (unbefristet) or fixed-term (befristet) |
| `workingTime` | Full-time, part-time, shift/night/weekend, mini-job - pick any combination |
| `remoteOnly` | Keep only home-office-capable postings |
| `includeTempAgencies` | Turn off to exclude staffing firms and see only direct employers |
| `accessibleJobs` | Only postings marked suitable for applicants with a disability |
| `maxPages` | How many 100-job pages to walk. Raise it only if a high `maxResults` is coming back short |
| `proxyConfiguration` | Standard Apify proxy input. Datacenter proxies are fine here |

#### A note on the two fixed-vocabulary filters

`occupationField` and `employer` are matched against the agency's own records, not as free text.

- **Occupation field** must be an exact Berufsfeld label, capitals included. `Softwareentwicklung und Programmierung` returns about 5,800 jobs; `Altenpflege` about 19,700; `Elektrotechnik` about 19,900. An invented label such as `Gesundheit` or `Logistik` returns **zero**, and so does the wrong case.
- **Employer** must be the full registered name. `Siemens AG` returns about 500 jobs and `Deutsche Bahn AG` about 3,500, while `Siemens` and `Deutsche Bahn` return **zero**.

If a run comes back empty with either of these set, that is almost always why.

#### A note on writing German place names

Type umlauts as real characters or as plain letters - `München` and `Munchen` both work and return the same results. The `ue`/`oe` spelling does **not**: `Muenchen` returns zero. The same applies to `Köln` versus `Koeln`.

#### A note on the remote filter

The job board's own remote search parameter covers only a narrow legacy teleworking category with a few dozen postings nationwide, so using it would hide almost everything. This actor instead reads the per-posting home-office flag, which is the field employers actually populate - roughly 40% of developer postings carry it. That filter is applied after fetching, so a run with **Remote-capable only** switched on may walk more pages to fill your result count.

### What it costs

Pricing is **pay-per-event** on Apify's built-in per-result event: you pay per job record returned and nothing at all for a run that finds no matches. There is **no per-run start fee**, so many small runs cost the same as one big one.

A worked example: every IT job within 50 km of Munich posted in the last seven days is about 220 records as this is written, which costs roughly **$0.66**. Running that same search every day for a month comes to about **$20**. Posting volumes move, so treat the record count as an order of magnitude rather than a quote.

### Typical uses

- **Job aggregators and job boards** - keep a German feed current without maintaining a scraper.
- **Recruiting and sourcing** - watch which employers are hiring for which roles, by city and by sector.
- **Labour-market research** - track posting volume by occupation, region, contract type or remote share over time.
- **Lead generation** - a company that is hiring twelve engineers is a company with a budget.

### Your feedback

If something is missing, wrong, or you need a field the agency publishes that this actor does not yet return, please open an issue on the **Issues** tab. Requests get read and acted on, and a short review helps other people find the actor.

### Disclaimer

This is an **unofficial** scraper. It is not affiliated with, endorsed by, or sponsored by the Bundesagentur für Arbeit / Arbeitsagentur. It reads only data that the agency publishes publicly through its own job-search interface, with no login and no access to private accounts.

#### Personal data in the output

Results may contain personal data (for example a named contact on a job posting). Personal data is protected by regulations such as the GDPR in the EU and the CCPA in California. You should not scrape or process personal data unless you have a legitimate reason to do so; if you are unsure whether your reason is legitimate, consult your lawyers.

# Actor input Schema

## `keywords` (type: `string`):

Job title or free-text search, e.g. 'developer', 'projektmanager', 'pflegefachkraft'. Searched server-side across the whole German market. Leave blank to return everything matching your other filters.

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

Stop after this many jobs. Use it to cap cost - 500 results costs about $1.50. Set 0 for no cap (bounded only by Max pages).

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

City or postcode to search around, e.g. 'Berlin', 'München', 'Hamburg', '10178'. Write umlauts as real characters or plain letters ('München' or 'Munchen'); the 'ue'/'oe' spelling ('Muenchen') returns nothing. Leave blank for all of Germany.

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

How far around the location to search, in kilometres, e.g. 25 for a city and its suburbs, 200 for a whole region. Ignored when no location is set.

## `occupationField` (type: `string`):

Restrict to one of the agency's occupational groups. This must match a Berufsfeld label EXACTLY, including capitals - it is a fixed vocabulary, not free text, and an invented value returns nothing. Working examples: 'Softwareentwicklung und Programmierung', 'Informatik', 'Altenpflege', 'Elektrotechnik', 'Kaufleute - Verkehr und Logistik'.

## `employer` (type: `string`):

Only jobs from this employer. Use the full registered name as the agency records it - 'Siemens AG' and 'Deutsche Bahn AG' both work, while 'Siemens' and 'Deutsche Bahn' return nothing.

## `publishedWithinDays` (type: `integer`):

Only jobs first published in the last N days, between 1 and 100, e.g. 7 for the last week. Leave 0 for no date limit.

## `offerType` (type: `string`):

What kind of position to return. 'Job' is ordinary employment; apprenticeships cover Ausbildung and dual study programmes.

## `contractType` (type: `string`):

Permanent (unbefristet) or fixed-term (befristet) contracts only.

## `workingTime` (type: `array`):

Working-time models to include, e.g. full-time only, or part-time plus mini-job. Leave empty for all.

## `remoteOnly` (type: `boolean`):

Keep only postings the employer flagged as home-office capable. Applied to the results after fetching, because the agency's own remote search filter covers only a narrow legacy teleworking category.

## `includeTempAgencies` (type: `boolean`):

Include postings from temporary-staffing firms (Zeitarbeit). Turn off to see only direct employers.

## `accessibleJobs` (type: `boolean`):

Only postings the employer marked as suitable for applicants with a disability.

## `maxPages` (type: `integer`):

How many result pages (100 jobs each) to walk. Raise it only when Max results is high and you are not getting enough rows back.

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

Proxy configuration. Datacenter proxies are fine for this source.

## Actor input object example

```json
{
  "keywords": "developer",
  "maxResults": 100,
  "radiusKm": 25,
  "publishedWithinDays": 0,
  "offerType": "",
  "contractType": "",
  "workingTime": [],
  "remoteOnly": false,
  "includeTempAgencies": true,
  "accessibleJobs": false,
  "maxPages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every job returned by the run, as rows 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 = {
    "keywords": "developer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zilicon/german-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 = { "keywords": "developer" }

# Run the Actor and wait for it to finish
run = client.actor("zilicon/german-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 '{
  "keywords": "developer"
}' |
apify call zilicon/german-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yZYLcHDHrW5JgS1R9/builds/LIiKgae492bQkXeoY/openapi.json