# Arbeitsagentur Jobs Scraper: German Job Listings (`transparent_meteorite/arbeitsagentur-jobs-scraper`) Actor

Scrape German job listings from the official Arbeitsagentur Jobsuche: title, employer, location, date, salary, contract, home office, apply link. No login, no API key.

- **URL**: https://apify.com/transparent_meteorite/arbeitsagentur-jobs-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 job scrapeds

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/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

## Arbeitsagentur Jobs Scraper: German Job Listings from the Official Jobsuche

Arbeitsagentur jobs, straight from the source. This Actor reads the official job search of the Bundesagentur fuer Arbeit (Jobsuche, the largest job board in Germany) and returns every listing as a clean row: title, employer, city and postcode, date posted, reference number, link, salary when the employer published one, contract, working time, home office flag, start date and apply link. There is no login, no API key, no proxy and no browser to manage.

Use it to build a German job feed, track hiring in a city or industry, source leads for recruiters and staffing agencies, feed a job board or an AI agent, or measure demand for a skill across Germany.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled search looks for `Softwareentwickler` within 25 km of Berlin and returns 25 jobs.
2. Click **Start**. A default run takes a few seconds.
3. Open the **Jobs** table in the Output tab, or export the dataset as JSON, CSV, Excel or XML.
4. Replace the search terms and location with your own and run again.

### What does this Actor do?

For each search term it asks the Jobsuche for matching listings, up to 100 per request, pages through the results until it has your limit, removes duplicates by reference number, and writes one row per job. Several search terms run in one go, and a job that matches two terms is returned once.

You can narrow a search by location and radius, by how recently the job was published, by full-time, part-time, shift work or mini-job, by permanent or fixed-term contract, by type of offer (job, apprenticeship, internship, self-employed) and by employer name. You can also keep only jobs where home office is possible.

Switch on **Include full description and salary range** to open each job and add the full description text and the salary amount when the employer gave one.

### Data you get

| Group | Fields |
|---|---|
| Core | `title`, `employer`, `location`, `postedAt`, `refNumber`, `url` |
| Pay | `salary`, `salaryMin`, `salaryMax`, `salaryPeriod` |
| Place | `city`, `postalCode`, `region`, `country`, `latitude`, `longitude`, `distanceKm` |
| Role | `occupation`, `professions`, `jobType`, `workTime`, `contractType`, `contractMonths` |
| Flags | `homeOffice`, `careerChangerFriendly` |
| Dates | `postedAt`, `startDate`, `modifiedAt` |
| Apply | `url` (the listing on arbeitsagentur.de), `applyUrl` (the employer's own page when there is one) |
| Text | `description` (with the details option) |
| Language | `germanLevel`, `germanLevelRank`, `germanSkill`, `englishMentioned`, `languagesMentioned` (with the details option) |
| Run | `scrapedAt` |

Fields the employer did not provide are `null`, never made up. Most German listings do not state a salary, so `salary` is `null` for many rows. When the Jobsuche only says that a pay type exists, the row still carries `salaryPeriod` (`hour` or `year`) and you can switch on the details option to get the amounts.

### What you get that other Arbeitsagentur scrapers do not return

Other Arbeitsagentur scrapers on the Store (for example blackfalcondata, crawloop, benthepythondev, perceptr0n) return the description as text and leave you to read it. With **Include full description and salary range** switched on, this Actor also reads the description for you and returns the language requirements as fields:

- `germanLevel`: the highest CEFR level (A1 to C2) the posting states for German, for example `B2`. `null` when the text names no level.
- `germanLevelRank`: the same level as a number, A1 = 1 to C2 = 6, so you can filter or sort ("German B1 or lower").
- `germanSkill`: the wording the employer used, for example "gute Deutschkenntnisse in Wort und Schrift", when there is no CEFR level.
- `englishMentioned` and `languagesMentioned`: whether the text mentions English, and which other languages it names.

This is text mining, not a guarantee. Many listings state no language level at all, and then these fields are `null` or empty; nothing is guessed. Without the details option they are `null` because no description is read.

### Input

| Field | What it does |
|---|---|
| `searchTerms` | One or more job titles or keywords, one per line. Required. German words match best (Pflegefachkraft, Elektriker, Buchhalter). |
| `location` | City, postcode or region in Germany. Empty means all of Germany. |
| `radiusKm` | Distance around the location, 0 to 200. Default 25. |
| `maxItems` | Total jobs to return across all terms. Default 25. |
| `publishedWithinDays` | Only jobs published in the last N days (1 to 100). |
| `workTime` | Full-time, part-time, shift or mini-job. |
| `contractType` | Permanent or fixed-term. |
| `jobType` | Job, apprenticeship, internship or self-employed. |
| `employer` | Only jobs from this employer name. |
| `homeOfficeOnly` | Keep only jobs flagged as home office possible. |
| `includeDetails` | Add description text and salary amounts, one extra request per job. |

### Example input

```json
{
  "searchTerms": ["Pflegefachkraft", "Altenpfleger"],
  "location": "Hamburg",
  "radiusKm": 30,
  "maxItems": 200,
  "publishedWithinDays": 7,
  "workTime": "fulltime",
  "includeDetails": true
}
```

### Output sample

```json
{
  "title": "Engineering Manager, Operations Technology (All genders)",
  "employer": "HelloFresh SE",
  "location": "10969 Berlin",
  "postedAt": "2026-11-09",
  "refNumber": "10000-1208597636-S",
  "url": "https://www.arbeitsagentur.de/jobsuche/jobdetail/10000-1208597636-S",
  "salary": null,
  "salaryMin": null,
  "salaryMax": null,
  "salaryPeriod": null,
  "city": "Berlin",
  "postalCode": "10969",
  "region": "BERLIN",
  "country": "DEUTSCHLAND",
  "latitude": 52.502166,
  "longitude": 13.4092125,
  "distanceKm": 1,
  "occupation": "Softwareentwickler/in",
  "professions": ["Softwareentwickler/in"],
  "jobType": "job",
  "workTime": ["fulltime"],
  "contractType": "fixed-term",
  "contractMonths": 24,
  "homeOffice": true,
  "careerChangerFriendly": false,
  "startDate": "2026-11-13",
  "modifiedAt": "2026-11-13T08:09:13.072",
  "applyUrl": null,
  "description": null,
  "scrapedAt": "2026-11-16T09:00:00.000Z"
}
```

The values above are an illustration. Your own run returns the live listings.

### Use cases

- **Recruiters and staffing agencies:** list every open role for a profession in your region, with employer names, to find companies that are hiring.
- **Job boards and aggregators:** feed a German section of your site with fresh, deduplicated listings and the employer's apply link.
- **Labour market research:** count openings by occupation, region or contract type, and track how demand changes week by week.
- **Salary and benefits benchmarking:** collect the listings that publish pay ranges and compare hourly and yearly pay by role.
- **Sales and lead generation:** employers who post jobs are growing. Use the employer names to build outreach lists for software, training and HR services.
- **AI agents and automation:** give an agent a live tool for German job search through the API or MCP.

### Limits

- Germany only. The Jobsuche covers listings registered with the Bundesagentur fuer Arbeit and its partners.
- The Jobsuche returns at most 10,000 results for one search. For bigger pulls split by location, radius or `publishedWithinDays`.
- Most listings do not publish a salary, so `salary` is often `null`.
- The home office filter is applied after the search, so very strict settings read more pages.
- The description is plain text as the Jobsuche stores it. Listings from partner boards link out to the employer's own page in `applyUrl`.

### Pricing and cost control

Pay per job: **$0.0009 per job on the free plan, $0.00055 on the Gold plan** (Bronze $0.00084, Silver $0.00072), plus a $0.00005 start fee per run. That is $0.90 per 1,000 jobs. Platform compute is included in the price, there is no extra monthly rental. Use **Max jobs** or the **Maximum cost per run** setting to cap spend; the run stops cleanly at the limit.

| Plan | Price per job | Per 1,000 jobs |
|---|---|---|
| Free | $0.0009 | $0.90 |
| Bronze | $0.00084 | $0.84 |
| Silver | $0.00072 | $0.72 |
| Gold and above | $0.00055 | $0.55 |

### Integrations and scheduling

Schedule the Actor daily with **Published within (days)** set to 1 and send the new jobs to Google Sheets, Slack, email, Make, Zapier or n8n with the Apify integrations. Use webhooks to start your own pipeline when a run finishes, or call the REST API and the Python and JavaScript clients.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~arbeitsagentur-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"searchTerms":["Softwareentwickler"],"location":"Berlin","maxItems":25}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/arbeitsagentur-jobs-scraper").call(run_input={"searchTerms": ["Softwareentwickler"], "location": "Berlin", "maxItems": 25})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["title"], row["employer"], row["location"])
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/arbeitsagentur-jobs-scraper`, paste the input JSON, then map the dataset items to your sheet or CRM.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/arbeitsagentur-jobs-scraper` to Claude, Cursor or any MCP client, and your agent can search German jobs as a tool.

### How it works and fair use

The Actor calls the public JSON interface behind the Jobsuche website, the same one the site itself uses. It paces its requests, retries on temporary errors, and stops cleanly before the run time limit, listing any search terms it could not finish in the `OUTPUT` record under `notChecked`. It returns only what the Jobsuche shows publicly on the web. It does not log in and does not read applicant data. Respect the terms of the data source and the data protection rules that apply to you, especially if you store contact details from listings. This is an independent tool and is not affiliated with or endorsed by the Bundesagentur fuer Arbeit.

### FAQ

**Do I need an API key or account?** No.

**Can I search in English?** Yes, many listings are in English and match English terms, but German titles give the widest coverage.

**How do I get all jobs in a city?** Use a broad term such as `Mitarbeiter` or several profession terms, set the location and radius, and raise Max jobs. Searches above 10,000 results should be split by date or radius.

**Why is salary empty?** Most employers in Germany do not state pay in the listing. Turn on the details option to get the amount when it exists.

**Will the same job appear twice?** No. Rows are deduplicated by reference number within a run. For scheduled runs, use a short `publishedWithinDays` window and deduplicate on `refNumber` in your pipeline.

**What happens with an empty or bad search?** The run finishes successfully with a clear message and nothing is charged.

**Can I get the employer's own apply page?** When the listing links out, `applyUrl` holds that page. Otherwise use `url`.

### Support

Found a search that reads badly? Open an issue on the Issues tab with the run URL and the search terms.

New to Apify? [Create a free account](https://console.apify.com/sign-up) and run this Actor in under a minute.

### Related actors

More tools from the same publisher that fit this workflow:

- [LinkedIn Public Jobs Scraper](https://apify.com/transparent_meteorite/linkedin-public-jobs): public LinkedIn job listings with salary and level
- [Workday Jobs Scraper](https://apify.com/transparent_meteorite/workday-jobs-scraper): jobs from Workday career sites with salary and remote filters
- [Career Site Jobs API](https://apify.com/transparent_meteorite/ats-open-roles): open roles from Greenhouse, Lever and other career sites
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain): enrich a domain with socials, emails and tech stack

Use from AI agents: every actor here is callable through the Apify MCP server (mcp.apify.com).

### Changelog

- **0.2**: Language requirements from the description: `germanLevel`, `germanLevelRank`, `germanSkill`, `englishMentioned`, `languagesMentioned`.
- **0.1**: First private build. Multi-term search, location and radius, date, working time, contract, offer type and employer filters, details mode, deadline guard.

# Actor input Schema

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

Job titles or keywords, one per line, for example Softwareentwickler, Pflegefachkraft or Elektriker. German terms match best.

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

City, postcode or region in Germany, for example Berlin, 80331 or Bayern. Leave empty to search all of Germany.

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

Search distance around the location. Ignored when no location is set.

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

Total number of jobs to return across all search terms. The Jobsuche API returns at most 10,000 results per search, so split big searches by location or date.

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

Only jobs published in the last N days. Leave empty for no date limit.

## `workTime` (type: `string`):

Only jobs with this working time.

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

Only permanent or only fixed-term jobs.

## `jobType` (type: `string`):

Only this type of offer.

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

Only jobs from this employer name.

## `homeOfficeOnly` (type: `boolean`):

Keep only jobs flagged as home office possible. This reads more pages, so a run may take longer.

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

Opens each job to add the full description text and the salary amount when the employer gave one. One extra request per job, so runs are slower.

## Actor input object example

```json
{
  "searchTerms": [
    "Softwareentwickler"
  ],
  "location": "Berlin",
  "radiusKm": 25,
  "maxItems": 25,
  "workTime": "",
  "contractType": "",
  "jobType": "",
  "homeOfficeOnly": false,
  "includeDetails": false
}
```

# Actor output Schema

## `jobs` (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 = {
    "searchTerms": [
        "Softwareentwickler"
    ],
    "location": "Berlin",
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/arbeitsagentur-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 = {
    "searchTerms": ["Softwareentwickler"],
    "location": "Berlin",
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/arbeitsagentur-jobs-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": [
    "Softwareentwickler"
  ],
  "location": "Berlin",
  "maxItems": 25
}' |
apify call transparent_meteorite/arbeitsagentur-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/arbeitsagentur-jobs-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/t7oLY8C3lcuYS7cVc/builds/JNzl4clMHL0g2FUz5/openapi.json
