# Arbeitsagentur Jobs: German Job Board Search by City & Radius (`yadroo/arbeitsagentur-jobs`) Actor

Job ads from Germany's federal employment agency board as rows: reference, title, occupation, employer, city, postcode, region, coordinates, start date, publication and update dates, ad URL. Filter by occupation, place and radius, home office, part time, apprenticeships, publication window.

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

## Pricing

from $0.70 / 1,000 job ad returneds

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: German Job Board Search by City & Radius

Job ads from Germany's federal employment agency board as rows: reference, title, occupation, employer, city, postcode, region, coordinates, start date, publication and update dates, ad URL. Filter by occupation, place and radius, home office, part time, apprenticeships, publication window.

Every row is one open position on the public job search of the **Bundesagentur für Arbeit**, Germany's federal employment agency — the board where employers, public bodies and regional institutions publish their vacancies themselves. Search it by occupation and commuting radius and get a table instead of a browser tab: reference number, title, occupation, employer, city, postcode, federal state, coordinates, distance, working time, contract, start date, first publication and last edit, plus the ad page. No API key, no proxy, no browser — the actor reads the same pages a visitor gets.

> **Need it tailored to your workflow?** Missing a field, a filter, another source or a different output format? [Open an issue](https://apify.com/yadroo/arbeitsagentur-jobs/issues) and describe what you need — we read every request and adapt the actor.

### Use cases

- **Regional sourcing by occupation**: all nursing, driving or engineering ads within a commute of one city, with distance per row, so a recruiter works one market at a time.
- **Ausbildung places for schools and portals**: set the kind of position to apprenticeship and get the dual-training market of a region — a category an ordinary job search never shows.
- **Home-office segment of a city**: keep only ads the employer marked as home office possible, instead of guessing from keywords in the title.
- **Direct employers only**: switch staffing agencies and private placement off and see which share of a shortage occupation is hired for in house.
- **A daily feed of new ads for a region**: no occupation, one city, a one-day publication window, `onlyNew` on and a schedule — every run reports the ads added since the last one.
- **Re-checking a saved shortlist**: paste the reference numbers you collected and see which ads are still open; a filled or withdrawn ad comes back with `found: false`.

### Input

Nothing is required: an empty input reads the newest ordinary job ads in all of Germany.

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `what` | string | empty | Occupation, job title or free term, handed to the board's own search exactly as typed (`Krankenpfleger`, `Berufskraftfahrer`). German terms find far more than English ones. Empty = every occupation. |
| `referenceNumbers` | string\[] | empty | Up to 50 board reference numbers (`10001-1003891446-S`); a whole ad URL is reduced to its number. Turns the run into a shortlist re-check and switches the search filters off. |
| `where` | string | empty | City, district, postcode or federal state (`Hamburg`, `München`, `10115`, `Nordrhein-Westfalen`). Empty = all of Germany, and then the radius is ignored. See [Places](#places). |
| `radiusKm` | integer | 25 | 0–200 km around the place, passed to the board as it stands. `0` keeps the place itself. A radius returns the whole commuting area. |
| `offerType` | string | `job` | One of `job`, `training`, `internship`, `selfEmployment` — see [Kind of position](#kind-of-position). Strict list. |
| `workingTime` | string\[] | empty | Any of `fullTime`, `partTime`, `homeOffice`, `shiftNightWeekend`, `miniJob` — see [Working time](#working-time). Several values widen the result. Strict list. |
| `contractType` | string | `any` | `any`, `permanent`, `temporary` — see [Contract](#contract). Strict list. |
| `employer` | string | empty | Keep only one employer's ads. The board matches the **full** registered name (`Da Vinci Engineering GmbH`), not a part of it. |
| `includeTempAgencies` | boolean | `true` | `false` removes ads placed by temporary staffing firms (Zeitarbeit). |
| `includePrivateRecruiters` | boolean | `true` | `false` removes ads placed by private placement agencies on behalf of an unnamed client. |
| `publishedWithinDays` | integer | empty | 0–100: keep only ads first published within that many days. The window moves with every run, so a scheduled task never needs editing. |
| `onlyNew` | boolean | `false` | Remember what this input returned and write only new or edited ads next time. The first run writes everything. |
| `includeDescription` | boolean | `false` | Add `description` (the advert text) and `employerAddress` by reading each ad's own page — one extra request per row. |
| `sort` | string | `newest` | `newest`, `relevance`, `startDate`, `distance` — see [Sort orders](#sort-orders). Decides which ads the row cap keeps. Strict list. |
| `maxItems` | integer | 50 | 1–1000 rows. The board serves 25 ads per request, so 50 rows are two requests and 1,000 rows forty. |
| `fields` | string\[] | all | Keep only these columns, in this order; `refnr`, `title`, `found`, `url` and `fetchedAt` are always kept (first, unless you list them, and then they stay where you put them). An unknown name is reported in the run status. |

### Reference

#### Kind of position

One run reads one kind, because the board files them in separate categories.

| Value | What it means |
|---|---|
| `job` | Ordinary employment (Arbeit) — the default. |
| `training` | Apprenticeship or dual study place (Ausbildung). |
| `internship` | Internship or trainee position (Praktikum/Trainee). |
| `selfEmployment` | An offer for self-employed work (Selbständigkeit). |

#### Working time

The marks the employer set on the ad. Picking several of them widens the result; empty means every working time.

| Value | What it means |
|---|---|
| `fullTime` | Vollzeit. |
| `partTime` | Teilzeit, in any of the board's shapes (morning, afternoon, evening, flexible). |
| `homeOffice` | The board's own "Homeoffice möglich" mark — remote work is possible, not necessarily full remote. |
| `shiftNightWeekend` | Shift, night or weekend work. |
| `miniJob` | Marginal employment (Minijob). |

#### Contract

| Value | What it means |
|---|---|
| `any` | Do not filter on the contract — the default, and the widest. |
| `permanent` | Only ads marked unbefristet. |
| `temporary` | Only ads marked befristet. |

Many ads leave the contract unset and drop out of the result as soon as you choose anything but `any`.

#### Sort orders

| Value | What it means |
|---|---|
| `newest` | Newest first publication first — the feed order, and the default. |
| `relevance` | The board's own ranking for your search term and place; it shifts through the day. |
| `startDate` | Earliest start date first. |
| `distance` | Nearest to the place first; needs `where`. |

`offerType`, `workingTime`, `contractType` and `sort` are strict lists: the platform refuses a value outside the list before the run even starts, with the allowed values in the error message. There is no spelling correction for them, and none is needed.

#### Places

`where` is free text and the board resolves it itself — a city, a district, a postcode or a federal state. Write it the way it is written in Germany; the ASCII spelling of an umlaut is tried in its German form as well (`Muenchen` is read as `München`, `Koeln` as `Köln`), and the spelling that was actually used is named in the run status. Any other place the board does not know stops the run with a message naming it, never a wider search. A radius always returns the commuting area: 25 km around Hamburg also brings Norderstedt and Pinneberg, so judge a row's location by its `city` and `distanceKm`.

#### Radius

Any whole number from 0 to 200 km is sent as it stands. The board's own interface offers 10, 15, 25, 50, 100 and 200 km, and those are the sizes most searches want: 25 km is a city plus its suburbs, 50 km a region, 100 km a federal state.

### Examples

**Nursing vacancies around Hamburg, newest first**

```json
{ "what": "Krankenpfleger", "where": "Hamburg", "radiusKm": 25, "sort": "newest", "maxItems": 25 }
```

**Home-office software jobs near Berlin, published in the last two weeks**

```json
{ "what": "Softwareentwickler", "where": "Berlin", "radiusKm": 50, "workingTime": ["homeOffice"], "publishedWithinDays": 14, "maxItems": 25 }
```

**IT apprenticeship places (Ausbildung) in Munich**

```json
{ "what": "Fachinformatiker", "where": "München", "radiusKm": 25, "offerType": "training", "maxItems": 25 }
```

**Everything published in the last day around Frankfurt am Main — put this on a schedule**

```json
{ "where": "Frankfurt am Main", "radiusKm": 25, "publishedWithinDays": 1, "onlyNew": true, "maxItems": 100 }
```

**Engineering jobs near Stuttgart, direct employers only, with the advert text**

```json
{ "what": "Ingenieur", "where": "Stuttgart", "radiusKm": 50, "includeTempAgencies": false, "includePrivateRecruiters": false, "includeDescription": true, "maxItems": 20 }
```

**Re-check a saved shortlist, four columns only**

```json
{ "referenceNumbers": ["10001-1003891446-S", "14751-63A6802-S"], "fields": ["title", "employer", "publishedAt"] }
```

### Output

One row per ad. A real row from the cloud run `DfyUaw8QqM1Sue0UY` (21 October 2026):

```json
{
  "refnr": "10001-1003893745-S",
  "title": "Fachkrankenpfleger (m/w/d) Intensivstation / Anästhesie | ab 5.344 € brutto",
  "found": true,
  "url": "https://www.arbeitsagentur.de/jobsuche/jobdetail/10001-1003893745-S",
  "occupation": "Pflegefachmann/-frau (Gesundheits- und Krankenpflege)",
  "employer": "RAN Experts GmbH",
  "city": "Hamburg",
  "postalCode": null,
  "region": "Hamburg",
  "country": "Deutschland",
  "latitude": 53.546048219,
  "longitude": 10.039313698,
  "distanceKm": 4,
  "employmentType": "Vollzeit, Schicht/Nacht/Wochenende",
  "contractType": "permanent",
  "startDate": "2026-10-21",
  "publishedAt": "2026-10-21",
  "modifiedAt": "2026-10-21T16:38:08.728Z",
  "offerType": "job",
  "isTempAgency": null,
  "externalUrl": null,
  "fetchedAt": "2026-10-21T22:27:28.927Z"
}
```

| Field | Type | When it is filled |
|---|---|---|
| `refnr` | string | Always — the board's reference number, also the end of the ad URL. |
| `title` | string | Always for an ad the board serves; `null` on a `found: false` row. |
| `found` | boolean | Always. `false` means the board no longer serves this reference number. |
| `url` | string | Always — the ad page on the board. |
| `occupation` | string | Normally — the occupation the ad is filed under. |
| `employer` | string | Normally; empty when the employer publishes anonymously through an agency. |
| `city`, `postalCode` | string | Normally; some ads carry the city without a postcode. |
| `region` | string | Normally — the federal state, in German spelling. |
| `country` | string | Normally (`Deutschland`; the board also carries a few cross-border ads). |
| `latitude`, `longitude` | number | Normally — the coordinates the board geocoded the workplace to. |
| `distanceKm` | number | When a place was given — whole kilometres from it. |
| `employmentType` | string | When the employer set a working-time mark, in the board's own words (`Vollzeit, Teilzeit, Schicht/Nacht/Wochenende, Homeoffice möglich, Minijob`). |
| `contractType` | string | When the ad carries a contract mark: `permanent` or `temporary`. |
| `startDate` | string | When the ad names one — date (UTC). |
| `publishedAt` | string | Normally — the first publication date (UTC). |
| `modifiedAt` | string | Normally — the employer's last edit, ISO 8601 UTC. |
| `offerType` | string | Always for an ad: the kind of position the board filed it under. |
| `isTempAgency` | boolean | Only with `includeDescription` — whether the ad is placed by a temporary staffing firm (only the ad page carries this mark). |
| `externalUrl` | string | When the employer publishes the ad on its own site or an application portal too. |
| `description` | string | Only with `includeDescription` — the advert text as the employer wrote it. |
| `employerAddress` | string | Only with `includeDescription` — street and town of the workplace, when the ad names them. |
| `fetchedAt` | string | Always — when this row was read, ISO 8601 UTC. |

**Contact persons, telephone numbers and e-mail addresses are never written to the dataset, in any setting.** Rows are built from a fixed list of columns, so nothing else from the board's records can leak into them.

Dataset views: **Job ads** (ad, employer, place, dates), **Location and commute** (coordinates, federal state, distance), **New and changed ads** (publication, last edit, start, kind, staffing mark, `found`).

### Use it from code / agents

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~arbeitsagentur-jobs/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"what":"Krankenpfleger","where":"Hamburg","radiusKm":25,"maxItems":25}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/arbeitsagentur-jobs').call({ what: 'Fachinformatiker', where: 'München', offerType: 'training', maxItems: 25 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/arbeitsagentur-jobs").call(run_input={"where": "Frankfurt am Main", "publishedWithinDays": 1, "maxItems": 50})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

`fields` decides the columns and their order: `{"fields": ["title", "employer", "city"]}` gives `refnr, found, url, fetchedAt, title, employer, city` — the always-kept columns you did not name come first, then yours exactly as you listed them.

MCP: add `https://mcp.apify.com` to Claude / Cursor / any MCP client and call the `yadroo/arbeitsagentur-jobs` tool with the same JSON input.

### Pricing

Pay per event: **$0.001 per run start + $0.001 per job ad written to the dataset**. Every run is charged the start event, also a run that finds nothing. Every row counts, including a `found: false` marker row for a reference number the board no longer serves — a marker row is a dataset item and is billed like any other.

| Run | Cost |
|---|---|
| 10 ads | $0.001 + 10 × $0.001 = **$0.011** |
| 50 ads (the default cap) | $0.001 + 50 × $0.001 = **$0.051** |
| 1,000 ads (the largest run) | $0.001 + 1,000 × $0.001 = **$1.001** |

Apify's subscription tiers discount the row price (Bronze −10 %, Silver −20 %, Gold and above −30 %); the start event is flat.

A run never spends more than the **Maximum cost per run** you set on the platform: it stops as soon as the next row would pass that limit, keeps every row you already paid for and says so in its status ("Stopped at your spending limit: N rows delivered").

### Limits & FAQ

- **Speed and what fits into one run.** Measured in the Apify cloud on 21 October 2026: the actor keeps itself to one request per second and one request brings 25 ads, so paging runs at roughly 1,400 ads per minute — the 50-row default finished in 6 seconds and the 1,000-row maximum takes about 40 seconds, both far inside the 15-minute default run timeout. With `includeDescription` on, every row costs one more request: 42 rows with their advert text in 45 seconds (44 requests), so about 58 rows per minute, and a 1,000-row run with the advert text would need some 17 minutes — more than the default timeout, so it stops early with the rows it has. Raise the run timeout or lower `maxItems` for that combination.
- **The actor stops before its run timeout instead of being killed.** When the time is nearly up it stops starting new work, keeps every row already read and ends with "Stopped before the run timeout: N rows saved". The same happens at your maximum cost per run. You never lose paid rows to a timeout.
- **Request pace and the source.** The board's robots.txt allows everything and sets no crawl delay, and no rate limit is documented (both read 21 October 2026), so the actor paces itself at 1 request/s with a burst of 2 and halves that whenever the board answers 429 or starts timing out. Larger runs simply take longer; they do not go faster. If the board refuses this server on the very first request — Apify servers share their addresses with other customers — the run fails fast with a message saying to start again in a few minutes, instead of burning the run.
- **Coverage.** The board holds the ads that employers published *there*. It is the largest single job board in Germany and the only place many public-sector and regional employers advertise, but it is not every German vacancy, and an ad can appear here days after it went live on the employer's own site.
- **Ads with missing marks.** Contract, start date, working time, postcode and coordinates are what the employer filled in. Ads that leave a mark empty disappear from the filter that uses it — that is why `contractType` defaults to `any`.
- **A radius is a commuting area, not a city.** Filter per row on `city` or `distanceKm` if you need the city itself, or use `radiusKm: 0`.
- **Ads disappear.** A position that is filled or withdrawn stops being served: it drops out of searches, and a reference-number lookup returns `found: false`. That marker row is the point of the shortlist mode — and it is billed like any row.
- **Search in German.** The board matches your term against the ad title, the occupation and the ad text. `Softwareentwickler` finds many times more than `software developer`.
- **The advert text is opt-in.** Rows carry structured facts by default. The agency's terms restrict reusing its content, and complete pages may not be republished, so the actor writes facts, adds the employer's own advert text only when you ask for it, and never republishes a page. Name the Bundesagentur für Arbeit as the source when you publish anything built from these rows.
- **Questions or problems:** open an issue on the Issues tab of this actor.

***

Made by **Yadroo**. Sibling actors: [hh-kz-vacancies](https://apify.com/yadroo/hh-kz-vacancies), [greenhouse-jobs](https://apify.com/yadroo/greenhouse-jobs), [workable-jobs](https://apify.com/yadroo/workable-jobs), [himalayas-remote-jobs](https://apify.com/yadroo/himalayas-remote-jobs), [osm-geocode](https://apify.com/yadroo/osm-geocode).

# Actor input Schema

## `what` (type: `string`):

What to look for, handed to the job board's own search exactly as you type it: an occupation (`Krankenpfleger`, `Berufskraftfahrer`, `Softwareentwickler`), a job title or a free term. The board matches it against the ad title, the occupation it is filed under and the ad text, so a German word finds far more than its English equivalent. No correction is applied here - the board decides what matches. Leave it empty to get every ad the other filters allow, which is how a run becomes a location feed.

## `referenceNumbers` (type: `array`):

Look up named ads instead of searching: one board reference number per line, as it stands in the ad URL (`10001-1003891446-S`). Surrounding spaces are ignored and a full ad URL is reduced to its reference number. Use it to re-check a shortlist: an ad the board no longer serves - filled, withdrawn or expired - comes back as one row with `found: false`, which is the cheapest way to see which of your saved ads are still open. The filters below are not applied to these rows.

## `where` (type: `string`):

City, district, postcode or federal state the search is centred on (`Hamburg`, `München`, `10115`, `Nordrhein-Westfalen`). The board resolves the place itself and measures the radius from it, so write it as Germans write it. An ASCII spelling of an umlaut is tried in its German writing as well (`Muenchen` is read as `München`) and the spelling that was actually used is named in the run status; any other place the board does not know stops the run with a clear message instead of a wider search. Leave it empty to search all of Germany, in which case the radius is ignored.

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

How far around the place to look, in kilometres. Any whole number from 0 to 200 is passed to the board as it stands - 0 keeps the place itself, 25 is the usual commute. A radius pulls in the whole commuting area: 25 km around Hamburg also returns Norderstedt and Pinneberg, so judge the location per row with `city` and `distanceKm`, not by the place you typed. Ignored when no place is given.

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

One run reads one kind of position, because the board files them in separate categories with different ad structures. `training` is the German Ausbildung market - thousands of apprenticeship places that never appear in an ordinary job search. Every row repeats what was asked for in `offerType`. The platform refuses any other value before the run starts.

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

Keep only ads carrying at least one of these working-time marks; several of them widen the result, they do not narrow it. `homeOffice` is the board's own remote mark, set by the employer, and it means remote work is possible, not that the job is fully remote. Empty = every working time. The platform refuses a value outside the list before the run starts.

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

Filters on the contract mark the employer set. Many ads leave it unset and disappear from the result as soon as you choose anything but `any`, so start with `any` and narrow only when the contract really decides.

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

Keep only ads of one employer. The board matches this against the employer name as it stands in its ads, in full: `Da Vinci Engineering GmbH` works, `Da Vinci` returns nothing. Copy the name from the `employer` column of an earlier run. Watch one employer by putting its name here and leaving the occupation empty.

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

Off: ads placed by Zeitarbeit firms are excluded, which is what sourcing for a direct employer needs - in shortage occupations such agencies place a large share of all ads and repeat them often. On (default): everything the board has.

## `includePrivateRecruiters` (type: `boolean`):

Off: ads placed by private recruiters on behalf of an unnamed client are excluded. Together with the switch above this is the "direct employers only" setting.

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

Keep only ads first published within this many days (`1` = today and yesterday, `7` = the last week, `30` = the last month). This is the field a schedule needs: the window moves with every run, so the task text never changes. It uses the first publication date, not the last edit, so an ad that was only touched up does not reappear.

## `onlyNew` (type: `boolean`):

Remember the reference numbers and update timestamps this run writes, and on the next run of the same actor or task write only ads that are new or that the employer has changed since - a watch list that reports openings instead of repeating the whole result. The first run writes everything. The memory belongs to the actor or task, so two tasks watching two cities never mix.

## `includeDescription` (type: `boolean`):

On: every row is completed from the ad's own record, adding `description` (the advert text as the employer wrote it) and `employerAddress`. That is one request per row on top of the search requests, so a 50-row run makes about 51 requests and takes roughly twice as long at the polite pace. Off (default) keeps runs short and writes only the structured facts. Contact persons, telephone numbers and e-mail addresses in those records are never written to the dataset, in any setting.

## `sort` (type: `string`):

The order the board answers in, and therefore which ads the row cap keeps. `newest` is the default here because it makes a repeated run a feed. `relevance` is the board's own ranking and shifts through the day. `distance` needs a place. The platform refuses any other value before the run starts.

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

Hard cap on the rows this run writes, and so on what it costs. The board serves up to 100 ads per request, so 50 rows is one request and 1,000 rows ten. A search with more hits than the cap is cut by the order you chose; the run status names the total the board reported, so you can see what you did not fetch. The run also stops at the maximum cost per run you set on the platform and says so in its status.

## `fields` (type: `array`):

Keep only the named columns, in this order - for example `title, employer, city, publishedAt`. Empty = every column. `refnr`, `title`, `found`, `url` and `fetchedAt` are always written; name one of them here and it moves to the position you gave it. An unknown name is reported in the run status rather than silently ignored.

## Actor input object example

```json
{
  "what": "Krankenpfleger",
  "where": "Hamburg",
  "radiusKm": 25,
  "offerType": "job",
  "contractType": "any",
  "includeTempAgencies": true,
  "includePrivateRecruiters": true,
  "onlyNew": false,
  "includeDescription": false,
  "sort": "newest",
  "maxItems": 50
}
```

# Actor output Schema

## `results` (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 = {
    "what": "Krankenpfleger",
    "where": "Hamburg"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/arbeitsagentur-jobs").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 = {
    "what": "Krankenpfleger",
    "where": "Hamburg",
}

# Run the Actor and wait for it to finish
run = client.actor("yadroo/arbeitsagentur-jobs").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 '{
  "what": "Krankenpfleger",
  "where": "Hamburg"
}' |
apify call yadroo/arbeitsagentur-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/arbeitsagentur-jobs"
        }
    }
}
```

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/dba0kZcomTSahaGVv/builds/mBhOLTT0Cu1WKxs3i/openapi.json