# Arbeitsagentur Scraper ($0.55/1K): German Jobs & Salaries (`tsutseisoftware/arbeitsagentur-scraper`) Actor

Scrape the Jobbörse of the Bundesagentur für Arbeit (arbeitsagentur.de), Germany's largest job board: ~1 million jobs with salary, employer, places, home office, contract and description; employer profiles, contacts, alerts.

- **URL**: https://apify.com/tsutseisoftware/arbeitsagentur-scraper.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (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.45 / 1,000 jobs

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 Jobbörse Scraper: German Jobs, Salaries & Employers

> **Auf Deutsch:** Scraper und API für die **Jobbörse der Bundesagentur für Arbeit**: Stellenangebote, Ausbildungsplätze und Praktika mit Gehalt, Arbeitgeber, Arbeitsort, Homeoffice, Befristung und Stellenbeschreibung, Arbeitgeberprofile, Job-Alerts per Slack, Telegram oder WhatsApp und Export nach Excel, CSV oder JSON.

Get job ads from the **Jobbörse of the Bundesagentur für Arbeit** (arbeitsagentur.de, Germany's largest job board with about **1 million jobs**) as clean, ready-to-use data. Search by **keyword**, **place** with a **radius**, **state**, **offer type** (jobs, apprenticeships, internships, self-employment), **working time**, **contract**, **home office**, **salary**, **industry**, **occupational field**, **profession**, **start date** and **date posted**, or paste any Jobbörse search or job URL. Every job comes with the **employer**, all **places with postcode and map point**, the **salary as numbers** (yearly, monthly and hourly) when the employer gives one, the **profession**, **start date** and the **apply link**; optionally the **full description**, the **employer's profile** and the **contacts** the ad shows.

**$0.55 per 1 000 jobs, with full descriptions $0.65.** No proxy setup and no extra platform costs.

Built for **recruiters, staffing agencies, HR tech, labour-market analysts and B2B sales teams** looking for companies that hire: schedule it daily in monitoring mode and get only the jobs that are new or changed, plus, if you want, the jobs that **were taken off**. Every run also saves a free **market summary**: median salaries, share of jobs with home office, top employers, professions, places and states.

### Why use this Arbeitsagentur scraper?

- 💶 **Salaries you can compare:** the employer's salary range as numbers, converted to yearly, monthly and hourly figures, with the original text.
- ♾️ **Every job of a large search:** the Jobbörse shows at most 10 000 jobs for one search; with **Max jobs** 0 the actor reads bigger searches in parts and says in the status if anything was left out.
- 🔎 **All the website's filters** (filtered-out jobs cost nothing), including all **144 occupational fields** to pick from and any **minimum share of home office**, plus **several searches with their own filters in one run** (`searches`) and the actor's own filters: title words, employers to leave out, place words, **postcode prefixes**, jobs with a map point only.
- 🧭 **Extra fields no other Jobbörse scraper gives:** the **seniority** the title states (junior, senior, team lead, working student, apprenticeship…), the **language of the ad** (German or English), days online, re-published jobs, temporary staffing and private recruiters marked.
- 🏢 **Employer profiles:** website, LinkedIn and other social media, headquarters, founding year, size, keywords and benefits.
- 📬 **Monitoring mode:** a daily feed of new and changed jobs (`changeType`, `changedFields`), optionally with **jobs taken off** (`expired` or `noLongerMatches`) or with the unchanged jobs too (the whole list with the changes marked).
- 🔔 **Job alerts without any integration:** send the saved jobs to **Slack, Discord, Telegram, WhatsApp** or your own **webhook** (with your own headers, e.g. an API key) after each run.
- 🔒 **Privacy first:** no names, e-mails or phone numbers of contact persons in the data by default (they are removed from the descriptions); employers that are private persons are saved without their name, street and map point. Contacts the ad shows are a paid opt-in.

#### How it compares with other Arbeitsagentur scrapers

An honest comparison with the Jobbörse scrapers most used in the Store (checked 2026-11-18), without naming them:

| Capability | This actor | Other scrapers |
|---|---|---|
| Keyword, place, radius, offer type, working time, contract, home office, date filters, URLs | yes | yes (some fewer) |
| Occupational field, profession, start date, salary and industry filters | yes | some |
| Several searches with their own filters in one run | yes | some |
| Full description | yes, $0.10 per 1 000 | included, or an extra charge |
| Every job of a search with more than 10 000 jobs | yes | some |
| Seniority and language of the ad | yes | rarely |
| Employer profile (website, social media, size, benefits) | yes | rarely |
| Monitoring of new and changed jobs, jobs taken off reported, unchanged jobs on request | yes | some (new jobs only) |
| Postcode prefixes, place words, jobs with a map point only | yes | rarely |
| Notifications to Slack, Discord, Telegram, WhatsApp or a webhook | yes | some |
| Market summary of every run | yes | rarely |
| Price per 1 000 jobs with descriptions (Free plan) | $0.65 | $0.70 to $2.00 |

### What data can you get?

| Group | Fields |
|---|---|
| Job | `title`, `url`, `jobId` (Referenznummer), `employmentType`, `contractTypes`, `fixedTermMonths`, `workTimes`, `isMiniJob`, `profession`, `professions`, `seniority`, `adLanguage`, `apprenticeshipType`, `studyProgram`, `educationRequired`, `suitableForCareerChangers`, `onlyForSeverelyDisabled`, `startDate`, `postedAt`, `refreshedAt`, `updatedAt`, `validThrough`, `daysOnline`, `isRepost` |
| Salary | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText`, `salaryYearlyMin/Max`, `salaryMonthlyMin/Max`, `salaryHourlyMin/Max`, `apprenticeshipPayMonthly` |
| Place | `location`, `locations` (every place; a search with a place lists the matching places, **Add job details** adds all of them), `postalCode`, `streetAddress`, `cityDistrict`, `region` (state), `country`, `gpsLat`, `gpsLon`, `distanceKm` |
| Home office | `workFromHome`, `workArrangement`, `remote`, `homeOfficePercent` |
| Employer | `company`, `companyId`, `companyLogoUrl`, `isPrivateEmployer`, `isTemporaryAgency`, `isPrivateAgency`, `isPartnerJob`, `partnerSite`, `applyUrl` |
| Employer profile (option) | `companyWebsite`, `companySocialLinks`, `companyHeadquarters`, `companyFoundedYear`, `companySize`, `companyKeywords`, `companyBenefits`, `companyDescription` |
| Text (option) | `description` (plain text or Markdown) |
| Contacts (paid option) | `contactNames`, `contactEmails`, `contactPhones` |
| Monitoring | `changeType`, `changedFields`, `firstSeenAt`, `removedAt`, `removedReason` |
| Raw data (option) | `rawData`: the job as the Jobbörse gives it (German field names), with the same privacy rules as the other fields (no contacts in its texts, no private employer's name, street or map point) |

How full the fields are (measured 2026-11-18 on 200 jobs for electricians, software developers, sales staff, nurses and drivers in München, Köln and Dresden): place, profession, start date and publication date 100 %, map point 94 %, postcode 88 %, employer logo 80 %, salary 37 % (the share depends a lot on the field: 93 % of nursing jobs from staffing agencies in Hamburg), street 10 %, apply link on a partner site 13 %. 51 % of the jobs came from temporary staffing agencies. 68 % of the ads show a contact person, e-mail or phone (paid option); 6 to 11 % of the employers were private persons (sole traders, practices) and are saved without their name.

### How to scrape the Jobbörse

1. Open the actor and enter one or more **Keywords** (e.g. `Python`, `Pflegefachkraft`, `Lagerhelfer`) and **Places** (e.g. `Berlin`, `10115`, `Bayern`), or paste **Jobbörse URLs** (a search or a job page).
2. Narrow it with the **Filters of the Jobbörse**: offer type, working time, contract, home office, salary, industry, occupational field, profession, start date, date posted.
3. Set **Max jobs** (0 = every job of the search).
4. Click **Start** and download the dataset as **JSON, CSV, Excel, XML or HTML**, or read it through the Apify API.
5. To watch a search, turn on **Monitoring: only new or changed jobs** and schedule the actor daily.

### Use cases

#### Software jobs in Berlin with salaries

```json
{
  "searchQueries": ["Softwareentwickler", "Python"],
  "locations": ["Berlin"],
  "radiusKm": 25,
  "onlyWithSalary": true,
  "maxItems": 200
}
```

#### Nursing jobs in Bavaria without temporary staffing, with descriptions

```json
{
  "searchQueries": ["Pflegefachkraft"],
  "locations": ["Bayern"],
  "excludeTemporaryAgencies": true,
  "includeDetails": true,
  "maxItems": 500
}
```

#### Apprenticeships starting next autumn in Hamburg

```json
{
  "offerType": "apprenticeship",
  "locations": ["Hamburg"],
  "startDateFrom": "2027-08-01",
  "startDateTo": "2027-10-31",
  "maxItems": 0
}
```

#### English-language IT jobs anywhere in Germany

```json
{
  "professionalFields": ["Softwareentwicklung und Programmierung", "Informatik"],
  "adLanguages": ["en"],
  "includeDetails": true,
  "maxItems": 300
}
```

#### New warehouse jobs every morning, with jobs taken off, to Slack

```json
{
  "searchQueries": ["Lagerhelfer"],
  "locations": ["Leipzig"],
  "radiusKm": 30,
  "onlyNewOrChanged": true,
  "monitoringKey": "warehouse-leipzig",
  "includeRemovedJobs": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxItems": 0
}
```

#### Several searches with their own filters

```json
{
  "searches": [
    {"keyword": "Python", "place": "München", "homeOffice": "full"},
    {"keyword": "Elektriker", "place": "Köln", "radiusKm": 50, "contractType": "permanent"},
    {"professions": ["Data Scientist"], "postedWithinDays": 7}
  ],
  "maxItems": 300
}
```

#### A search or a job from the website

Paste a search from the address bar of the Jobbörse (it keeps its own filters) or a job page into **Jobbörse URLs**, or a reference number such as `10001-1004024986-S` into **Reference numbers**. Single jobs are read with their details.

#### Every job of a large search

The Jobbörse lists at most 10 000 jobs of one search. With **Max jobs** 0 (or above 10 000) a bigger search is read in parts (by state, then by industry), and the status says if some jobs could still not be reached.

#### Monitoring mode

The actor remembers the jobs of earlier runs with the same **Monitoring key** and saves only jobs that are new or whose title, employer, places, home office or salary changed. Unchanged jobs are not saved and not charged; every page of up to 100 jobs read in this mode is a small "Monitoring page" charge. With **Max jobs**, each search watches its first N jobs in the chosen order: with newest first, a "new" job is a new opening among the newest N. With **Monitoring: report jobs taken off**, jobs of the previous run that are no longer in the search come as rows with `changeType: "removed"` and `removedReason` `expired` (taken off the Jobbörse, often filled) or `noLongerMatches` (still online, no longer in your search). With **Monitoring: also return unchanged jobs**, every run returns the whole list, unchanged jobs with `changeType: "unchanged"` (charged like any job).

#### Contacts (optional, personal data)

With **Add contacts (paid)** each job gets the contact persons, e-mail addresses and phone numbers the employer wrote in the ad or its profile (`contactNames`, `contactEmails`, `contactPhones`), never for an employer that is a private person. In our sample 68 % of the ads had at least one. These are personal data: you are responsible for using them lawfully (GDPR). The descriptions never contain them.

#### Market summary (SUMMARY)

Every run saves a free summary to the key-value store (record `SUMMARY`): jobs saved and read per search with the number the Jobbörse reports, share with a salary and with home office, median yearly salary and hourly wage, top employers, professions and places, jobs by state and offer type, and how many jobs each filter left out.

### How much does it cost to scrape the Jobbörse?

Pay per event; the prices are also on the **Pricing** tab. Platform costs are included.

| Event | Price | When |
|---|---|---|
| Job saved in the dataset | **$0.55 / 1 000** (Bronze $0.52, Silver $0.49, Gold and higher $0.45) | every saved row |
| Actor start | $0.003 per run | once per run |
| Job details | $0.10 / 1 000 | a saved job with its full description, only with **Add job details** (also every job looked up by URL or reference number) |
| Employer profile | $0.20 / 1 000 | a saved job whose employer has a profile, only with **Add employer profiles** |
| Contact details | $0.40 / 1 000 | a saved job with at least one contact, only with **Add contacts (paid)** |
| Monitoring page | $0.30 / 1 000 | monitoring mode: every page of up to 100 jobs read, and every check of a job gone from the search |
| Extra page | $0.30 / 1 000 | pages beyond what the saved jobs explain (narrow filters of the actor that leave out most jobs). If the saved jobs don't cover a run's cost, the difference is charged as extra pages; the log says how many. A normal run pays nothing here. |
| Notification | $0.001 per run | a run that sent its notification (all channels together) |

| Typical run | Price (Free plan) | Typical time |
|---|---|---|
| 20 jobs (the example input) | $0.014 | a few seconds |
| 1 000 jobs | $0.55 | under 30 s |
| 1 000 jobs with full descriptions | $0.65 | about 4 to 5 minutes |
| Daily monitoring of a search with 500 jobs, 20 new | $0.016 | a few seconds |

You can set a maximum cost per run; the actor stops when it is reached.

### Input example

```json
{
  "searchQueries": ["Python"],
  "locations": ["Berlin"],
  "radiusKm": 25,
  "workTime": ["fullTime"],
  "homeOffice": "possible",
  "includeDetails": true,
  "maxItems": 50
}
```

### Output example

```json
{
  "id": "arbeitsagentur.de:10001-1004024986-S",
  "source": "arbeitsagentur.de",
  "url": "https://www.arbeitsagentur.de/jobsuche/jobdetail/10001-1004024986-S",
  "jobId": "10001-1004024986-S",
  "title": "Senior Python Developer (m/w/d)",
  "company": "Beispiel Software GmbH",
  "location": "Berlin",
  "locations": ["Berlin"],
  "postalCode": "10117",
  "region": "Berlin",
  "country": "DE",
  "gpsLat": 52.517,
  "gpsLon": 13.388,
  "workFromHome": "partial",
  "workArrangement": "hybrid",
  "salaryMin": 65000,
  "salaryMax": 80000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "salaryText": "65 000–80 000 EUR / year",
  "salaryMonthlyMin": 5417,
  "salaryHourlyMin": 33.85,
  "employmentType": "job",
  "contractTypes": ["permanent"],
  "workTimes": ["fullTime"],
  "profession": "Softwareentwickler/in",
  "seniority": "senior",
  "adLanguage": "de",
  "isTemporaryAgency": false,
  "startDate": "2026-12-01",
  "postedAt": "2026-11-17",
  "daysOnline": 1,
  "isRepost": false,
  "description": "Ihre Aufgaben: Entwicklung von Backend-Services in Python …",
  "detailScraped": true,
  "contactEmails": null,
  "changeType": null,
  "scrapedAt": "2026-11-18T10:00:00+00:00"
}
```

Extra export formats: a printable HTML report or a Markdown table of the results, besides Excel, CSV and JSON (**Export formats**).

### Limitations

- About a third of the jobs give a salary (it depends a lot on the field); the rest have `salaryMin` and `salaryMax` null.
- The Jobbörse also lists jobs of partner job boards (`isPartnerJob`); their full description is on the partner's site (`applyUrl`), so `description` can be short or empty for them.
- **Seniority** comes from the title only; most titles state no level (`seniority` null). **Language of the ad** is reliable with **Add job details**; from a title alone it is often null.
- **Posted or updated within (hours)** counts a job by the hour of its last update, because the Jobbörse gives the publication only as a day.
- Free text may mention a person by name (e.g. "you will report to …"); e-mails, phone numbers and the names of contact persons are removed.
- Employer names that look like a private person (a practice, a sole trader) are hidden together with their street, map point and logo; in doubt, privacy wins (6 to 11 % of the employers in our samples). Companies trading as a KG or OHG under a made-up name are shown.
- A request the website rejects is asked again a little later; if rejections continue, the run stops with what it has saved and says so. The actor never solves captchas or other challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/arbeitsagentur-scraper").call(run_input={
    "searchQueries": ["Data Engineer"], "locations": ["München"], "maxItems": 100,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["salaryYearlyMin"], job["salaryYearlyMax"], job["url"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["medianYearlySalary"], summary["topEmployers"][:10])
```

**Leave out empty fields** drops the fields without a value from each row. **Max jobs with details** reads the full description only for the first N jobs. **Compact output** keeps the core fields (title, employer, place, salary, home office, contract, working time, profession, seniority, dates, apply link, URL) plus the fields of the options you turned on: smaller rows for AI agents, MCP clients and spreadsheets.

### Troubleshooting

- **"… is not a Jobbörse reference number"**: use the end of a job URL, e.g. `10001-1004024986-S`.
- **"The Jobbörse does not know the places you gave"** or **"places unknown to the Jobbörse"**: check the spelling (e.g. `München`, `Köln`) or use a postcode. A state (`Bayern`, `Sachsen`) means the whole state; write `Berlin (Bundesland)` for the whole city state.
- **"Sort by: distance" needs a place**: add a city or postcode.
- **"Searches" #N: unknown key …**: use the field names listed in the description of **Searches** (e.g. `keyword`, `place`, `homeOffice`).
- **"… searches with more than 10,000 jobs …"**: the search was bigger than the Jobbörse lists even in parts; narrow it with a place or a filter.
- **"Your maximum cost per run is too low …"**: raise the maximum cost per run in the run options.
- **"The Jobbörse refused the requests"** or **"started refusing requests"**: try again later, or set the proxy to Apify Proxy (automatic).

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### More job scrapers

Jobs from another source, with salaries and monitoring:

- [StepStone Scraper](https://apify.com/tsutseisoftware/stepstone-scraper): jobs from StepStone in Germany, Austria, Belgium and the Netherlands: salary as numbers, hiring signals, monitoring
- [SEEK Scraper](https://apify.com/tsutseisoftware/seek-scraper): jobs from SEEK in Australia and New Zealand: salary as numbers, past the 550-job limit, hiring signals, removed jobs
- [Welcome to the Jungle Scraper](https://apify.com/tsutseisoftware/welcome-to-the-jungle-scraper): jobs from Welcome to the Jungle in France, Europe and the US: salary as numbers, company profile, closed jobs, alerts
- [XING Jobs Scraper](https://apify.com/tsutseisoftware/xing-jobs-scraper): jobs from XING in Germany, Austria and Switzerland: full description, salary as numbers, past the 1,000-job limit, removed jobs, alerts
- [LinkedIn Jobs Scraper](https://apify.com/tsutseisoftware/linkedin-jobs-scraper): public LinkedIn jobs in any country without login: salary as numbers, seniority, applicants, hiring signals, new and removed jobs, alerts
- [Career Site Job Search & Scraper](https://apify.com/tsutseisoftware/ats-jobs-scraper): jobs straight from company career sites on Greenhouse, Workday, Lever, Ashby and SmartRecruiters in any country, including the jobs that just closed

### FAQ

#### Is it legal to scrape the Jobbörse?

It reads only publicly available job ads, without logging in, slows down when the website asks and never solves captchas or other challenges. It returns contacts only if you turn on **Add contacts (paid)** (then you are responsible for using them lawfully) and always removes e-mails, phone numbers and the names of contact persons from the texts. The website's terms of use may restrict extracting its data; you are responsible for how you use the data (privacy laws, database rights and the website's terms). If in doubt, consult a lawyer. This actor is not affiliated with the Bundesagentur für Arbeit.

#### Why is the employer empty for some jobs?

The employer name is a private person's name (a practice or a sole trader). For privacy the name, logo, street and map point are left out.

#### Does it find apprenticeships and internships?

Yes: set **Offer type** to apprenticeships (Ausbildung and dual studies), internships (also traineeships and working students), self-employment or all offers.

#### Do I need a proxy?

No. The default setting works and costs you nothing extra.

#### Can I use it from an AI agent or through MCP?

Yes. Use **Compact output** for smaller rows, and call the actor through the Apify API or Apify's MCP server.

Also known as an Arbeitsagentur API, Jobbörse API, Bundesagentur für Arbeit jobs scraper or Jobsuche export (German: "Stellenangebote der Arbeitsagentur", "Jobbörse Scraper", "Stellenanzeigen exportieren").

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/arbeitsagentur-scraper/changelog.md

# Actor input Schema

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

What to search, as you would type it on the Jobbörse: a job title, a skill or a profession (e.g. Python, Pflegefachkraft, Lagerhelfer, Elektriker). Each keyword is a separate search; empty = all jobs.

## `locations` (type: `array`):

Where: a city (Berlin, München), a postcode (10115), a state (Bayern, Sachsen, Nordrhein-Westfalen: the whole state) or a country (Deutschland, Österreich). Each place is searched for every keyword. Empty = all of Germany and abroad.

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

Maximum number of jobs saved. You pay per saved job. 0 = no limit (a search with more than 10,000 jobs is read in parts).

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

Around a city or postcode (0–200 km). Empty = the website's default (25 km); not used for a state or a country.

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

Search pages copied from the browser with any filters (e.g. https://www.arbeitsagentur.de/jobsuche/suche?angebotsart=1\&was=Python\&wo=Berlin\&umkreis=25) and job pages (https://www.arbeitsagentur.de/jobsuche/jobdetail/10001-1004024986-S), read with their job details. A search URL keeps its own filters.

## `searches` (type: `array`):

Several searches in one run, each with its own filters: a list of objects with "keyword", "place", "radiusKm", "employer" and any filter of the Jobbörse section below by its field name (offerType, workTime, contractType, homeOffice, minHomeOfficePercent, postedWithinDays, postedWithinHours, minYearlySalary, minHourlyWage, onlyWithSalary, industries, professionalFields, professions, startDateFrom, startDateTo, excludeTemporaryAgencies, excludePrivateAgencies, excludeExternalJobBoards, onlyCareerChangers, onlyForSeverelyDisabled, sortBy). What an entry leaves out comes from the inputs of this form. Example: \[{"keyword": "Python", "place": "Berlin", "homeOffice": "full"}, {"keyword": "Pflegefachkraft", "place": "Hamburg", "radiusKm": 50, "workTime": \["partTime"]}].

## `jobIds` (type: `array`):

Jobbörse reference numbers (Referenznummer, the end of a job URL, e.g. 10001-1004024986-S): each job is read with its job details.

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

Which kind of offers.

## `workTime` (type: `array`):

Only jobs with one of these working times (empty = any).

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

Permanent or fixed-term contracts only.

## `homeOffice` (type: `string`):

"Possible" includes jobs with home office by arrangement; the percentages count only jobs that give one.

## `minHomeOfficePercent` (type: `integer`):

Only jobs that give at least this share of home office (e.g. 30 or 80); overrides "Home office".

## `postedWithinDays` (type: `integer`):

Only jobs published (or published again) in the last N days; 0 = today. E.g. 1 for a daily run.

## `postedWithinHours` (type: `integer`):

Only jobs published or updated on the Jobbörse in the last N hours (e.g. 6 for a run every 6 hours). The Jobbörse gives the publication only as a day, so a job counts by the hour of its last update.

## `startDateFrom` (type: `string`):

Only jobs whose start date (Eintrittsdatum) is on or after this day. Empty = also jobs starting immediately.

## `startDateTo` (type: `string`):

Only jobs whose start date is on or before this day (e.g. jobs starting by the end of next month). With only this date, jobs starting immediately are included.

## `minYearlySalary` (type: `integer`):

Only jobs whose employer gives a yearly salary reaching this amount (the top of the range counts, as on the website). About a quarter of the jobs give a salary.

## `minHourlyWage` (type: `number`):

Only jobs whose employer gives an hourly wage reaching this amount. With a min yearly salary too, a job passes when either one fits.

## `onlyWithSalary` (type: `boolean`):

Only jobs whose employer gives a yearly salary or an hourly wage.

## `industries` (type: `array`):

Only employers of these industries (Branche; empty = any).

## `professionalFields` (type: `array`):

Only jobs of these occupational fields of the Jobbörse (all 144, in German as on the website, e.g. Softwareentwicklung und Programmierung, Altenpflege, Lagerwirtschaft, Post und Zustellung, Güterumschlag). Several = any of them.

## `professions` (type: `array`):

Only jobs of these professions, written as the Jobbörse filter shows them (e.g. Data Scientist, Softwareentwickler/in, Pflegefachmann/-frau). Several = any of them.

## `employers` (type: `array`):

Only jobs of these employers, written exactly as the Jobbörse shows them (e.g. BWI GmbH, Deutsche Bahn AG). Each employer is a separate search.

## `excludeTemporaryAgencies` (type: `boolean`):

Leave out jobs of temporary staffing agencies (Arbeitnehmerüberlassung).

## `excludePrivateAgencies` (type: `boolean`):

Leave out jobs offered through private recruitment agencies (private Arbeitsvermittlung).

## `excludeExternalJobBoards` (type: `boolean`):

Leave out jobs the Jobbörse takes over from partner job boards (they are applied for on the partner's website).

## `onlyCareerChangers` (type: `boolean`):

Only jobs open to applicants from other professions.

## `onlyForSeverelyDisabled` (type: `boolean`):

Only jobs offered exclusively to severely disabled people or their equals.

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

Order of the results. Newest first is best for monitoring new jobs.

## `titleKeywords` (type: `array`):

Keep only jobs whose title contains at least one of these words (e.g. Senior, Werkstudent).

## `excludeTitleKeywords` (type: `array`):

Leave out jobs whose title contains any of these words (e.g. Praktikum, Minijob).

## `excludeCompanies` (type: `array`):

Leave out jobs of employers whose name contains any of these words (e.g. Personal, Zeitarbeit).

## `locationKeywords` (type: `array`):

Keep only jobs whose place, postcode, district or state contains at least one of these words (e.g. Mitte, 80331, Bayern), e.g. to keep a radius search to some districts.

## `postalCodePrefixes` (type: `array`):

Keep only jobs whose postcode starts with one of these (e.g. 80 and 81 for München, 104 for Berlin-Kreuzberg).

## `onlyWithCoordinates` (type: `boolean`):

Leave out jobs without GPS coordinates (e.g. for a map).

## `seniorityLevels` (type: `array`):

Only jobs of these levels, as the title states them (field seniority). Most titles state none: add "Not stated in the title" to keep those too.

## `adLanguages` (type: `array`):

Only ads written in these languages (field adLanguage), e.g. English for international candidates. Reliable with "Add job details" (judged on the description); without them only titles that clearly show the language are judged and the rest are kept.

## `excludeReposts` (type: `boolean`):

Leave out jobs the employer published again (first published earlier than the current publication), to keep only really new openings.

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

Read every job page: the full job description, whether the job is offered through temporary staffing or a private recruiter, the education required and the partner job board. Charged as "Job details" ($0.10 per 1,000 jobs).

## `maxDetails` (type: `integer`):

Read job details (and employer profiles, contacts) only for the first N saved jobs; the rest are saved with the search data. 0 or empty = all.

## `descriptionFormat` (type: `string`):

How the job description is saved (with "Add job details").

## `descriptionMaxLength` (type: `integer`):

Cut descriptions longer than this many characters (at a word). 0 or empty = the full description.

## `includeEmployerProfile` (type: `boolean`):

The employer's profile on the Jobbörse: website, LinkedIn and other social media, headquarters, founding year, size, keywords, employee benefits and the employer's description. Read once per employer; charged as "Employer profile" ($0.20 per 1,000 jobs) only for jobs whose employer has a profile. Never for private employers.

## `includeContacts` (type: `boolean`):

E-mail addresses, phone numbers and contact persons the employer wrote in the job ad or in its profile, in separate fields. Charged as "Contact details" ($0.40 per 1,000 jobs with a contact) only for jobs with at least one contact. Never for private employers. These are personal data: you are responsible for using them lawfully (GDPR). The description itself never contains them.

## `compactOutput` (type: `boolean`):

Only the main fields: title, employer, place, salary, home office, contract, working time, profession, dates, the apply link and the monitoring fields (plus the details you turned on).

## `omitEmptyFields` (type: `boolean`):

Rows without the fields that have no value (null or empty list): smaller rows for JSON and AI agents. Spreadsheets get the same columns either way.

## `includeRawData` (type: `boolean`):

Adds the job exactly as the Jobbörse gives it (German field names) in the field rawData, for your own processing. With "Add job details" it is the job page's data. The same privacy rules apply as to the other fields: no e-mails, phone numbers or contact persons in its texts, nothing that names a private employer.

## `maxItemsPerSearch` (type: `integer`):

Maximum per keyword × place (or search URL). Empty = no limit.

## `onlyNewOrChanged` (type: `boolean`):

Return new jobs, and jobs whose title, employer, places, home office or salary changed (with the changed fields). With "Max jobs", each search watches its first N jobs in the chosen order: with newest first, a "new" job is a new opening among the newest N.

## `monitoringKey` (type: `string`):

Name of the remembered state; use a different key for every saved search. Empty = "default".

## `includeUnchanged` (type: `boolean`):

Return the unchanged jobs too, with changeType unchanged (charged like any job), so every run has the whole current list with the changes marked.

## `includeRemovedJobs` (type: `boolean`):

Jobs of the previous run that are no longer in the search: the actor checks each one and returns it with removedReason expired (taken off the Jobbörse, often filled) or noLongerMatches (still online, no longer in your search). Each check is charged as a monitoring page.

## `telegramBotToken` (type: `string`):

Token of your bot from @BotFather.

## `telegramChatId` (type: `string`):

Chat, group or channel to send to (e.g. 123456789 or -1001234567890).

## `slackWebhookUrl` (type: `string`):

Incoming webhook (https://hooks.slack.com/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n, your server): receives the jobs as JSON.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `webhookHeaders` (type: `object`):

HTTP headers sent with the webhook, e.g. {"Authorization": "Bearer <your token>"} for a server that needs a key. Header values are hidden in error reports.

## `notificationLimit` (type: `integer`):

How many jobs the message lists.

## `notifyOnlyChanges` (type: `boolean`):

No message after a run that saved nothing.

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

No proxy needed. If the Jobbörse keeps refusing your runs, switch to Apify Proxy (automatic).

## `exportFormats` (type: `array`):

Off by default. Printable HTML report: the results as a clean, branded table with the main columns, made for printing, saving as PDF or sending to someone; for working with the data use Excel or CSV, which have every field. Markdown table: the same columns as text for AI tools, docs or GitHub. The Output tab links the files. Each file has the overview columns of every saved row and nothing is left out, so a run with tens of thousands of rows makes a file of tens of MB that can be slow to open; for big runs use the dataset or its Excel export. Excel (XLSX), CSV and JSON are always in the Output tab and under Export, at no extra cost.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searchQueries": [
    "Python"
  ],
  "locations": [
    "Berlin"
  ],
  "maxItems": 20,
  "offerType": "job",
  "contractType": "any",
  "homeOffice": "any",
  "onlyWithSalary": false,
  "excludeTemporaryAgencies": false,
  "excludePrivateAgencies": false,
  "excludeExternalJobBoards": false,
  "onlyCareerChangers": false,
  "onlyForSeverelyDisabled": false,
  "sortBy": "newest",
  "onlyWithCoordinates": false,
  "excludeReposts": false,
  "includeDetails": false,
  "descriptionFormat": "text",
  "includeEmployerProfile": false,
  "includeContacts": false,
  "compactOutput": false,
  "omitEmptyFields": false,
  "includeRawData": false,
  "onlyNewOrChanged": false,
  "includeUnchanged": false,
  "includeRemovedJobs": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "exportFormats": [],
  "sendErrorReports": true
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `excel` (type: `string`):

All saved rows as an Excel file, with every field.

## `htmlReport` (type: `string`):

The saved rows with the main columns as a clean table to print, save as PDF or send; only when "Extra export formats" includes it. Excel has every field.

## `markdown` (type: `string`):

The saved rows as a Markdown table, handy for AI tools, docs and GitHub; only when "Extra export formats" includes Markdown.

# 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": [
        "Python"
    ],
    "locations": [
        "Berlin"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/arbeitsagentur-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": ["Python"],
    "locations": ["Berlin"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/arbeitsagentur-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 '{
  "searchQueries": [
    "Python"
  ],
  "locations": [
    "Berlin"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/arbeitsagentur-scraper --silent --output-dataset

```

## MCP server setup

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