# Arbeitsagentur Scraper — German Job Listings & Employer Data (`studio-amba/arbeitsagentur-scraper`) Actor

Scrape job listings, employers, locations, and posting dates from Arbeitsagentur.de, Germany's Federal Employment Agency job board. Fast public-API access, no login.

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

## Pricing

from $8.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Arbeitsagentur Scraper

Extract **job listings from [Arbeitsagentur.de](https://www.arbeitsagentur.de/jobsuche/)**, the official job board of the German Federal Employment Agency (Bundesagentur für Arbeit) — the largest single source of vacancies in Germany with well over a million active postings.

This Actor pulls **job titles, employers, locations, occupations, posting dates, start dates, and reference numbers** directly from the public Jobsuche API. No login, no cookies, no browser automation. It is fast and stable because it reads structured data straight from the source instead of scraping HTML.

### What does Arbeitsagentur Scraper do?

Give it a German keyword (for example `verkäufer`, `softwareentwickler`, or `pflegekraft`) and, optionally, a location. The Actor queries the Federal Employment Agency's Jobsuche API, paginates through the results, and returns clean, structured records you can download as JSON, CSV, Excel, or HTML — or pull through the Apify API into your own systems.

Because it runs on the Apify platform, you also get scheduling, monitoring, proxy rotation, and integrations (webhooks, Make, Zapier, Google Sheets) out of the box.

### Why use Arbeitsagentur Scraper?

- **Largest job pool in Germany.** The Bundesagentur für Arbeit aggregates vacancies from employers and dozens of external job boards in one place.
- **Labour-market research.** Track hiring demand by occupation, region, or employer over time.
- **Recruitment and sourcing.** Build lead lists of companies actively hiring for a role.
- **Salary and skills analysis.** Combine occupation and location data to map the German job market.
- **Job aggregators.** Feed a niche job site or newsletter with fresh, structured listings.
- **No anti-bot headaches.** The public API is open, so runs are fast and reliable.

### How to scrape Arbeitsagentur data

1. Open the Actor and go to the **Input** tab.
2. Enter a **Search Query** in German (e.g., `verkäufer`, `elektroniker`, `bürokauffrau`).
3. Optionally set a **Location** (city, region, or postal code) and a **Search Radius** in kilometres.
4. Optionally set **Published Within (days)** to only get recent postings.
5. Set **Max Results** to control how many listings you want.
6. Click **Start**. When the run finishes, open the **Output** tab and download your data as JSON, CSV, Excel, or HTML.

That's it. You can also schedule the Actor to run daily and be notified of new listings.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchQuery` | string | German keyword to search for. Defaults to `verkäufer`. |
| `location` | string | City, region, or postal code. Leave empty to search all of Germany. |
| `radius` | integer | Radius in km around the location (only applies with a location). |
| `publishedSince` | integer | Only return jobs published within this many days. |
| `maxResults` | integer | Maximum number of listings to return (default 100). |
| `proxyConfiguration` | object | Proxy settings. Apify datacenter proxies from Germany work well. |

#### Example input

```json
{
  "searchQuery": "softwareentwickler",
  "location": "Berlin",
  "radius": 25,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### Output

Each job is returned as one dataset record. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output item

```json
{
  "jobTitle": "Verkäufer (m/w/d)",
  "employer": "Skechers USA Deutschland GmbH",
  "occupation": "Verkäufer/in",
  "location": "Berlin",
  "postalCode": "10179",
  "street": "Grunerstraße 20",
  "region": "Berlin",
  "country": "Deutschland",
  "latitude": 52.520013,
  "longitude": 13.4151885,
  "distanceKm": 1,
  "publishedDate": "2026-07-08",
  "entryDate": "2026-07-09",
  "modifiedDate": "2026-07-09T07:50:57.416",
  "referenceNumber": "10001-1003355569-S",
  "isExternalPosting": false,
  "externalUrl": null,
  "url": "https://www.arbeitsagentur.de/jobsuche/jobdetail/10001-1003355569-S",
  "scrapedAt": "2026-07-09T21:10:00.000Z"
}
```

#### Data fields

| Field | Description |
| --- | --- |
| `jobTitle` | Job posting title |
| `employer` | Hiring company or organisation |
| `occupation` | Standardised occupation / profession |
| `location` | City or town of the workplace |
| `postalCode` | Postal code (PLZ) |
| `street` | Street address |
| `region` | Federal state or region (Bundesland) |
| `country` | Country of the workplace |
| `latitude` / `longitude` | Workplace coordinates |
| `distanceKm` | Distance from the searched location |
| `publishedDate` | Date the job was published |
| `entryDate` | Earliest possible start date |
| `modifiedDate` | Last modification timestamp |
| `referenceNumber` | Arbeitsagentur reference number |
| `isExternalPosting` | True if the job comes from an external board |
| `externalUrl` | Link to the original external posting, if any |
| `url` | Arbeitsagentur job detail page URL |
| `scrapedAt` | ISO 8601 collection timestamp |

### How much does it cost to scrape Arbeitsagentur?

The Actor reads a lightweight JSON API, so runs are cheap and fast. A typical run of a few hundred listings finishes in well under a minute and uses a tiny amount of compute. Pricing follows this Actor's pay-per-result configuration on the Apify Store — check the pricing box on the Actor page for the current rate. Larger runs simply scale linearly with the number of results.

### Tips and advanced options

- **Narrow with location + radius.** Combine `location` and `radius` to focus on a commuting area.
- **Fresh listings only.** Use `publishedSince` (e.g., `7`) to pull just the last week's postings when scheduling daily runs.
- **German keywords.** The board is German. Use German job titles for the best coverage.
- **Deduplication.** Results are de-duplicated by reference number within a run.

### FAQ, disclaimers, and support

**Is scraping Arbeitsagentur legal?** This Actor reads a public API that the Federal Employment Agency exposes for its own web and mobile clients. Use the data responsibly and in line with applicable terms and data-protection law. You are responsible for how you use the extracted data.

**Do I need an account or API key?** No. The Actor handles API access for you. No login or cookies are required.

**Why are some jobs marked as external?** Many postings on Arbeitsagentur are syndicated from other job boards. Those items have `isExternalPosting: true` and, where available, an `externalUrl` to the original posting.

**Something's not working.** Open an issue on the Actor's **Issues** tab with your input and the run link. Custom fields or a tailored version can also be arranged.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search for (German). Examples: 'verkäufer' (sales assistant), 'softwareentwickler' (software developer), 'pflegekraft' (care worker), 'lkw fahrer' (truck driver).

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

Filter by city, region, or postal code (e.g., 'Berlin', 'München', 'Hamburg', '10115'). Leave empty to search all of Germany.

## `radius` (type: `integer`):

Radius around the location in kilometres. Only applies when a location is set.

## `publishedSince` (type: `integer`):

Only return jobs published within this many days (e.g., 7 for the last week). Leave empty for all.

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

Maximum number of job listings to return.

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

Proxy settings. The Jobsuche API is public and open, so Apify datacenter proxies work well.

## Actor input object example

```json
{
  "searchQuery": "verkäufer",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQuery": "verkäufer",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "searchQuery": "verkäufer",
    "maxResults": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/arbeitsagentur-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "verkäufer",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/arbeitsagentur-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arbeitsagentur Scraper — German Job Listings & Employer Data",
        "description": "Scrape job listings, employers, locations, and posting dates from Arbeitsagentur.de, Germany's Federal Employment Agency job board. Fast public-API access, no login.",
        "version": "0.1",
        "x-build-id": "EBDLCnqCtTldtJscy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~arbeitsagentur-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-arbeitsagentur-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/studio-amba~arbeitsagentur-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-arbeitsagentur-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/studio-amba~arbeitsagentur-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-arbeitsagentur-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for (German). Examples: 'verkäufer' (sales assistant), 'softwareentwickler' (software developer), 'pflegekraft' (care worker), 'lkw fahrer' (truck driver)."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by city, region, or postal code (e.g., 'Berlin', 'München', 'Hamburg', '10115'). Leave empty to search all of Germany."
                    },
                    "radius": {
                        "title": "Search Radius (km)",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Radius around the location in kilometres. Only applies when a location is set."
                    },
                    "publishedSince": {
                        "title": "Published Within (days)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return jobs published within this many days (e.g., 7 for the last week). Leave empty for all."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. The Jobsuche API is public and open, so Apify datacenter proxies work well."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```