DEV Community: Gleanery Works

The Arbeitsagentur Jobsuche API in 2026: search 1 million German jobs with Python (v6 endpoint)

Gleanery Works — Wed, 21 Oct 2026 07:20:46 +0000

The job board of Germany's Federal Employment Agency (Bundesagentur für Arbeit, arbeitsagentur.de/jobsuche) lists over 1 million open jobs: the largest job database in Germany, covering everything from nurses and electricians to software developers and apprenticeships. Its frontend talks to a JSON API that is open to everyone with a fixed public key.

Many tutorials and wrappers still use the old /pc/v4/jobs search endpoint, which now returns HTTP 403. Here's what works today (checked October 2026).

Search: `/pc/v6/jobs`

import requests

API = "https://rest.arbeitsagentur.de/jobboerse/jobsuche-service/pc"
HEADERS = {"X-API-Key": "jobboerse-jobsuche", "Accept": "application/json"}

r = requests.get(f"{API}/v6/jobs", headers=HEADERS, params={
    "was": "Softwareentwickler",   # what: job title or keyword
    "wo": "Berlin",                # where: city or postal code
    "umkreis": 25,                 # radius in km
    "size": 100, "page": 1,
})
data = r.json()
print(data["maxErgebnisse"], "matching jobs")
for job in data["ergebnisliste"]:
    print(job["stellenangebotsTitel"], "|", job.get("firma"), "|", job["stellenlokationen"][0]["adresse"].get("ort"))

Each result has the title, employer (firma), workplace address with coordinates, working-time flags, contract type (vertragsdauer), home office flag (homeofficemoeglich), publication date and the reference number (referenznummer).

Parameters that work

Parameter	Values	Meaning
`was`	text	job title or keyword
`wo`, `umkreis`	city/PLZ, km	location and radius
`angebotsart`	1 job, 2 self-employment, 4 apprenticeship, 34 internship	offer type
`arbeitszeit`	`vz`, `tz`, `snw`, `mj`, joined with `;`	full-time, part-time, shift/night/weekend, mini job
`befristung`	1 fixed-term, 2 permanent	contract
`veroeffentlichtseit`	0, 1, 7, 14, 28	published within N days (other values are ignored)
`zeitarbeit`	`false`	exclude temp agencies (Zeitarbeit)
`pav`	`false`	exclude private placement agencies
`arbeitgeber`	exact employer name	one employer
`page`, `size`	size up to 100	pagination

Two gotchas:

10,000 results max per query. page * size above 10,000 returns HTTP 400. Split big searches by location or date.
There's no home office search parameter in v6. Filter on homeofficemoeglich == True yourself.

The response also contains facetten (facet counts per occupation, city, employer, working time…), which is handy for labor-market statistics without downloading jobs.

Salaries

About a quarter of listings state pay:

for job in data["ergebnisliste"]:
    if "gehaltsspanneVon" in job:          # range
        print(job["gehaltsspanneVon"], "-", job["gehaltsspanneBis"], job["verguetungsangabe"])
    elif "festgehalt" in job:              # fixed amount
        print(job["festgehalt"], job["verguetungsangabe"])

verguetungsangabe is the unit: JAHRESGEHALT (yearly), STUNDENLOHN (hourly) or KEINE_ANGABEN (none).

Details: still `/pc/v4/jobdetails`, base64-encoded

The full description is on a separate endpoint. Unlike search, it's still v4, and it wants the reference number base64-encoded:

import base64

ref = data["ergebnisliste"][0]["referenznummer"]
enc = base64.b64encode(ref.encode()).decode()
detail = requests.get(f"{API}/v4/jobdetails/{enc}", headers=HEADERS).json()
print(detail["stellenangebotsBeschreibung"][:500])
print(detail.get("istArbeitnehmerUeberlassung"), detail.get("allianzpartnerName"))

The details add the description, the temp-agency and private-recruiter flags, and allianzpartnerName/allianzpartnerUrl. Careful: the "Allianzpartner" is whoever delivered the posting, which is often a partner job board (jobvector, yourfirm…) and not the employer, so don't treat its URL as the company website unless the names match.

The public job page is https://www.arbeitsagentur.de/jobsuche/jobdetail/{referenznummer}.

Skip the plumbing

If you'd rather not handle pagination, the 10k cap, detail requests, salary normalization and English field names yourself, I packaged all of this as an Apify actor: Arbeitsagentur Jobs Scraper. It returns flat JSON (title, companyName, city, salaryMin, salaryMax, salaryInterval, remote, isTempAgency…), adds filters like remoteOnly, minSalaryYearly and excludeTempAgencies, and has a monitoring mode for daily feeds. It costs $2 per 1,000 jobs.

For AI agents

It's also callable as an MCP tool, for example from Claude or Cursor:

https://mcp.apify.com?tools=gleanery_actors/arbeitsagentur-jobs-scraper

Ask "find part-time nursing jobs in Hamburg posted this week, direct employers only" and the agent fills in the input. More job and B2B data tools for agents: github.com/gleanery-works/job-and-supplier-data-mcp.

Get every open job from Greenhouse, Lever and Ashby in 40 lines of Python

Gleanery Works — Tue, 20 Oct 2026 12:45:53 +0000

If you want to build a job board, track which companies are hiring, or benchmark salaries, you don't need to scrape HTML. Most companies' careers pages are hosted by an applicant tracking system (ATS), and the three most common ones with startups (Greenhouse, Lever and Ashby) all have public, unauthenticated JSON endpoints. The careers page itself calls them.

1. Find out which ATS a company uses

Open the careers page and click any job. The URL tells you:

URL contains	ATS	Slug
`boards.greenhouse.io/stripe` or `job-boards.greenhouse.io/stripe`	Greenhouse	`stripe`
`jobs.lever.co/palantir`	Lever	`palantir`
`jobs.ashbyhq.com/openai`	Ashby	`openai`

If the careers page lives on the company's own domain, view the source and search for those hostnames: the job list is usually embedded from one of them.

2. Call the endpoint

import requests

HEADERS = {"User-Agent": "my-job-tracker/1.0 (you@example.com)"}

def greenhouse(slug):
    r = requests.get(f"https://boards-api.greenhouse.io/v1/boards/{slug}/jobs",
                     params={"content": "true"}, headers=HEADERS, timeout=30)
    for j in r.json()["jobs"]:
        yield {"title": j["title"], "location": j["location"]["name"],
               "department": (j.get("departments") or [{}])[0].get("name"),
               "url": j["absolute_url"], "posted": j.get("first_published")}

def lever(slug):
    skip = 0
    while True:
        page = requests.get(f"https://api.lever.co/v0/postings/{slug}",
                            params={"mode": "json", "skip": skip, "limit": 100},
                            headers=HEADERS, timeout=30).json()
        for j in page:
            yield {"title": j["text"], "location": j["categories"].get("location"),
                   "department": j["categories"].get("team"), "url": j["hostedUrl"],
                   "remote": j.get("workplaceType") == "remote",
                   "salary": j.get("salaryRange")}
        if len(page) < 100:
            break
        skip += 100

def ashby(slug):
    r = requests.get(f"https://api.ashbyhq.com/posting-api/job-board/{slug}",
                     params={"includeCompensation": "true"}, headers=HEADERS, timeout=30)
    for j in r.json()["jobs"]:
        comp = (j.get("compensation") or {}).get("compensationTierSummary")
        yield {"title": j["title"], "location": j.get("location"),
               "department": j.get("department"), "url": j["jobUrl"],
               "remote": j.get("isRemote"), "salary": comp}

for job in ashby("openai"):
    print(job)

That's it: no API key, no headless browser, and no HTML parsing.

3. Salary ranges

Pay-transparency laws in New York, California, Colorado, Washington and soon the EU mean many postings now carry a salary range, and the APIs expose it:

Ashby: compensation.summaryComponents[] has minValue, maxValue, currencyCode and interval per component (salary, equity, bonus).
Lever: salaryRange with min, max, currency, interval (e.g. per-year-salary).
Greenhouse: not in the list response. Fetch each job with ?pay_transparency=true and read pay_input_ranges[] (min_cents, max_cents, currency_type).

def greenhouse_pay(slug, job_id):
    d = requests.get(f"https://boards-api.greenhouse.io/v1/boards/{slug}/jobs/{job_id}",
                     params={"pay_transparency": "true"}, headers=HEADERS, timeout=30).json()
    return [(p["min_cents"] / 100, p["max_cents"] / 100, p["currency_type"])
            for p in d.get("pay_input_ranges", [])]

4. Gotchas I hit

Greenhouse EU boards live on boards-api.eu.greenhouse.io.
Lever EU accounts use api.eu.lever.co.
Slugs are not company names. "Hugging Face" might be huggingface or hugging-face, and on some ATSs a generic slug like remote or figure belongs to a different company. Check the company name the API returns before trusting a guessed slug.
Be polite. These endpoints serve real careers pages. Cache, keep concurrency low and send a User-Agent with contact info.

Beyond these three

Enterprise employers use Workday (a POST API with a 20-item page limit and a total that only appears on page 1), and European companies often use Personio (XML), Recruitee, SmartRecruiters or Workable. I documented the endpoints for 11 ATSs, with their pagination quirks and salary fields, here: github.com/gleanery-works/ats-job-apis.

If you'd rather not maintain eleven integrations, I also run them as a hosted tool, Career Site Jobs Scraper. You give it company names, and it finds each company's ATS and returns one normalized schema with salary min/max. It can also return only jobs that are new since the last run, which is handy for hiring-signal alerts. It's pay per result ($2 per 1,000 jobs), and Apify's free monthly credit covers small projects.

Giving an AI agent access to job data

If the consumer is an LLM agent rather than your own code, you can skip the integration entirely and expose the tool over MCP:

claude mcp add --transport http jobs "https://mcp.apify.com?tools=gleanery_actors/career-site-jobs-scraper"

Then ask: "Which of Datadog, Snowflake and Figma opened data-engineering roles this week, and what do they pay?" The agent calls the tool with {"companies": [...], "titleKeywords": ["data engineer"], "postedWithinDays": 7} and gets normalized JSON back. Setup for Cursor, Claude Desktop and VS Code is in gleanery-works/job-and-supplier-data-mcp.

What are you building with job data? I'm curious which ATSs people still miss.