We have published the aggregate tables behind the Job Opportunities API (JOA) Job Market Report, September 2026 as an open dataset, on Hugging Face and as a citable Zenodo record. It is one CSV of 803 rows with a data dictionary, licensed CC BY 4.0. Every row carries its sample size n. The report itself, with the full text, charts, a Markdown version and an audio edition, is at jobopportunitiesapi.org/reports/job-market-september-2026.

What is in it

On 4 October 2026 JOA held a snapshot of 2,111,453 open employer-direct postings from 144,098 employers. The report analyses the 1,385,899 located in North America (986,641) and Europe (399,258). The tables cover regions and countries, pay in postings, how old stated posting dates are, employer concentration, work model, role families, a weekly panel and a comparison with official vacancy statistics. There are no individual postings, employer names or personal data in the files.

One finding worth a look

Austria has required job adverts to state a minimum pay since 2011; Germany has no such rule. Austrian postings are about four times as likely as German ones to state a pay figure: 4.4 to 1 on a blind, AI-assisted sampled estimate (interval 2.9 to 6.2), and 6.9 to 1 on automated detection (33.7% against 4.9%). The gap holds within every recruiting system with at least 150 Austrian postings.

In the United States, 24.4% of own-site postings in the 10 jurisdictions with a pay-range posting law have pay detected in a structured field, against 18.7% in 28 states without one (both are lower bounds: detection misses some stated pay). That is an association, and states differ in other ways.

A note on method

The pay measure was tested before publication: two AI readers with web access labelled stratified random samples blind to our flags, a script verified each quoted passage against the text, and a rule-based second detector agreed with the readers on 97.6% of Austrian and 91.0% of German postings. The Methodology section of the report also explains how employer-direct data differs from job-board and aggregator data and from official statistics, which is why the two should be read side by side. Across the 51 US jurisdictions, JOA's postings follow the official JOLTS distribution by state (rank correlation 0.96).

Using the data

Load it with the Hugging Face datasets library or read the CSV directly; the dictionary describes every column. Please cite the report and, for the tables, the DOI. If you find an error, write to hello@jobopportunitiesapi.org with the subject "Market report correction".

Every "best job API" list claims something about sourcing, freshness and data quality. Claims are cheap. Requests are not: send the same kind of request to several APIs and you can see what actually comes back.

This tutorial does that. We send one real request to each of seven job data sources, measure five things in the responses, and print a comparison table. The script is plain Python 3, standard library only, and it needs no sign-up for six of the seven sources.

Disclosure. I build Job Opportunities API (JOA), which is one of the seven, and I recommend it below for some uses. JOA, Erioun and Kaeros are all made by the same small studio, so read my conclusions with that in mind. I included JOA because I can test it with a free key; the other six are queried exactly as their public documentation describes, with no key. I report what came back, including the places JOA looks worse than the others.

What we measure

These five checks come from questions I ask before trusting any job feed:

1. Where does the apply link go? To the employer's application page, or to a page owned by the API vendor?

2. Is there text? Does each row carry the job description, not just a title and a link?

3. Is there a salary? Only counted when the response to this exact request contains one.

4. Are there duplicates? Rows with the same title, company and location inside one response.

5. Can the API say a role has closed? And can it say which fields were stated by the employer and which were guessed? Here we look at what the response format can express, then check it with a real call where it exists.

Setup

You need Python 3.9 or newer. For the Job Opportunities API row, create a free Explore key (no card) and export it. The other sources need nothing.

read -rs JOA_API_KEY && export JOA_API_KEY   # paste your free key, press Enter (optional: without it the Job Opportunities API row is skipped)
python3 compare_job_apis.py

Two courtesy notes. Remotive asks API users to make at most about four requests a day, so do not put this in a loop. And the single-employer sources (Greenhouse, Lever, Ashby) are queried for one company each, to show the shape of their public job board APIs; they are not market-wide.

The script

It sends one request per source, normalises each row into the same small structure, and summarises. The apply-link classifier is deliberately simple: a link on the vendor's own domain counts as "the vendor's own page", a known applicant-tracking-system host counts as an application page, and anything else is "another domain".

#!/usr/bin/env python3
"""Send ONE real request to each job API and measure what comes back.

Python 3.9+, standard library only. Optional: export JOA_API_KEY=... (free Explore key)
to include Job Opportunities API. No other key is needed.
"""
import json, os, re, sys, urllib.request
from collections import Counter
from urllib.parse import urlparse

UA = "job-api-comparison-script/1.0"
ATS_HOSTS = ("greenhouse.io", "lever.co", "ashbyhq.com", "myworkdayjobs.com", "smartrecruiters.com",
             "join.com", "teamtailor.com", "recruitee.com", "personio.de", "personio.com", "workable.com",
             "comeet.com", "bamboohr.com", "icims.com", "jobvite.com")

def get(url, key=None):
    headers = {"User-Agent": UA}
    if key:
        headers["Authorization"] = "Bearer " + key
    with urllib.request.urlopen(urllib.request.Request(url, headers=headers), timeout=40) as r:
        return json.load(r)

def row(title, company, location, apply_url, has_desc, salary, date, source_host):
    return dict(title=title or "", company=company or "", location=location or "",
                apply_url=apply_url or "", has_desc=bool(has_desc), salary=bool(salary),
                date=date, source_host=source_host)

# One function per source: returns (rows, schema_flags). schema_flags says what the API's own
# fields can express: does a row carry a closed/last-checked field, and per-field provenance?
def arbeitnow():
    d = get("https://www.arbeitnow.com/api/job-board-api")["data"][:50]
    return [row(j["title"], j["company_name"], j["location"], j["url"], j["description"], False,
                j["created_at"], "arbeitnow.com") for j in d], dict(closed=False, verified=False, provenance=False)

def muse():
    d = get("https://www.themuse.com/api/public/jobs?page=1")["results"]
    return [row(j["name"], j["company"]["name"], (j["locations"] or [{}])[0].get("name"),
                j["refs"]["landing_page"], j["contents"], False, j["publication_date"], "themuse.com")
            for j in d], dict(closed=False, verified=False, provenance=False)

def remotive():
    d = get("https://remotive.com/api/remote-jobs")["jobs"][:50]
    return [row(j["title"], j["company_name"], j["candidate_required_location"], j["url"], j["description"],
                j["salary"], j["publication_date"], "remotive.com") for j in d], dict(closed=False, verified=False, provenance=False)

def greenhouse(board="stripe"):  # ONE employer's public board
    d = get("https://boards-api.greenhouse.io/v1/boards/%s/jobs?content=true" % board)["jobs"][:50]
    return [row(j["title"], j.get("company_name") or board, (j.get("location") or {}).get("name"),
                j["absolute_url"], j.get("content"), False, j.get("first_published"), "greenhouse.io")
            for j in d], dict(closed=False, verified=False, provenance=False)

def lever(site="palantir"):  # ONE employer's public postings
    d = get("https://api.lever.co/v0/postings/%s?mode=json&limit=50" % site)
    return [row(j["text"], site, (j.get("categories") or {}).get("location"), j.get("applyUrl") or j["hostedUrl"],
                j.get("descriptionPlain"), j.get("salaryRange"), j.get("createdAt"), "lever.co")
            for j in d], dict(closed=False, verified=False, provenance=False)

def ashby(board="ashby"):  # ONE employer's public postings
    d = get("https://api.ashbyhq.com/posting-api/job-board/%s?includeCompensation=true" % board)["jobs"][:50]
    return [row(j["title"], board, j.get("location"), j.get("applyUrl") or j["jobUrl"],
                j.get("descriptionPlain"), (j.get("compensation") or {}).get("compensationTierSummary"), j.get("publishedAt"), "ashbyhq.com")
            for j in d], dict(closed=False, verified=False, provenance=False)

def joa():
    key = os.environ.get("JOA_API_KEY")
    if not key:
        return None, None
    d = get("https://api.jobopportunitiesapi.org/v1/jobs?country=DE&limit=50", key)["data"]
    return [row(j["title"], j["company"], j.get("city"), j.get("apply_url"), j.get("has_description"),
                (j.get("field_sources") or {}).get("salary") == "published", j.get("posted_at"), "jobopportunitiesapi.org")
            for j in d], dict(closed=True, verified=True, provenance=True)

def classify(r):
    host = urlparse(r["apply_url"]).netloc.lower()
    if r["source_host"] in host and not any(h in r["source_host"] for h in ATS_HOSTS):
        return "the vendor's own page"
    if any(h in host for h in ATS_HOSTS):
        return "an ATS application page"
    return "another domain" if host else "no link"

def summarise(name, rows, flags):
    n = len(rows)
    keys = [(r["title"].lower(), r["company"].lower(), r["location"].lower()) for r in rows]
    dupes = n - len(set(keys))
    kinds = Counter(classify(r) for r in rows)
    pct = lambda x: "%d%%" % round(100 * x / n) if n else "-"
    return [name, n, pct(sum(r["has_desc"] for r in rows)), pct(sum(r["salary"] for r in rows)),
            pct(sum(bool(r["date"]) for r in rows)), dupes,
            ", ".join("%s %s" % (pct(v), k) for k, v in kinds.most_common(2)),
            "yes" if flags["closed"] else "no", "yes" if flags["provenance"] else "no"]

def joa_closed_check():
    key = os.environ.get("JOA_API_KEY")
    if not key:
        return None
    d = get("https://api.jobopportunitiesapi.org/v1/jobs/closed?country=DE&limit=5", key)["data"]
    ok = sum(1 for j in d if j.get("closed_at") and j.get("closed_reason"))
    return "Job Opportunities API /v1/jobs/closed: %d of %d rows carry closed_at and closed_reason" % (ok, len(d))

HEAD = ["source", "rows", "has text", "has salary", "has date", "dupes", "apply link goes to", "closed roles?", "field provenance?"]

if __name__ == "__main__":
    out = [HEAD]
    for name, fn in [("Arbeitnow", arbeitnow), ("The Muse", muse), ("Remotive", remotive),
                     ("Greenhouse (1 employer)", greenhouse), ("Lever (1 employer)", lever),
                     ("Ashby (1 employer)", ashby), ("Job Opportunities API (DE)", joa)]:
        try:
            rows, flags = fn()
            if rows is None:
                print("skipping %s (set JOA_API_KEY)" % name, file=sys.stderr)
                continue
            out.append(summarise(name, rows, flags))
        except Exception as e:
            print("%s failed: %s" % (name, e), file=sys.stderr)
    for r in out:
        print(" | ".join(str(c) for c in r))
    try:
        line = joa_closed_check()
        if line:
            print()
            print(line)
    except Exception as e:
        print("closed check failed: %s" % e, file=sys.stderr)

What came back (3 October 2026, 14:38 UTC)

source | rows | has text | has salary | has date | dupes | apply link goes to | closed roles? | field provenance?
Arbeitnow | 50 | 100% | 0% | 100% | 0 | 100% the vendor's own page | no | no
The Muse | 20 | 100% | 0% | 100% | 0 | 100% the vendor's own page | no | no
Remotive | 16 | 100% | 56% | 100% | 0 | 100% the vendor's own page | no | no
Greenhouse (1 employer) | 50 | 100% | 0% | 100% | 1 | 100% another domain | no | no
Lever (1 employer) | 50 | 100% | 0% | 100% | 0 | 100% an ATS application page | no | no
Ashby (1 employer) | 50 | 100% | 100% | 100% | 0 | 100% an ATS application page | no | no
Job Opportunities API (DE) | 50 | 92% | 8% | 100% | 2 | 96% an ATS application page, 4% another domain | yes | yes

Job Opportunities API /v1/jobs/closed: 5 of 5 rows carry closed_at and closed_reason

Reading the table:

• Apply links. Arbeitnow, The Muse and Remotive link to their own pages for every row. That is normal for an aggregator or board and is part of how they get traffic, but it means one more click before the candidate reaches the employer. Lever and Ashby link to an application page on the ATS. Greenhouse's link goes to another domain, which for a single employer like Stripe is the company's own site. JOA's sample linked to an ATS page in 96% of rows and another domain in the rest.

• Text and salary. Text is present nearly everywhere (Greenhouse needs ?content=true to include it, which the script requests). Salary is the uneven field: none for Arbeitnow, The Muse, Lever or Greenhouse in this request, 56% for Remotive, and 100% for Ashby's own jobs, which says more about that one company than about Ashby. JOA's German sample had a published salary on 8% of rows. That is low, and it is why JOA's own documentation tells you to filter with require_fields=salary when salary matters. Employers mostly do not publish one.

• Duplicates. One in Greenhouse's 50 rows and two in JOA's 50 share a title, company and location. Those may be genuinely separate openings for the same role, so treat this as a prompt to look, not an error count. The aggregator samples showed none, but they were small.

• Closed roles and provenance. None of the other six responses carries a closure date or a list of closed roles, and none marks which fields the source stated. JOA does: every row has closed_at, closed_reason, last_verified_at and a field_sources block that marks each field published, inferred or absent. The last line of the output is a real call to JOA's closed-roles endpoint with a free key: all five rows came back with a closure date and reason.

What this does not tell you

A single request is a sample, not a benchmark. Specifically it does not tell you:

• Coverage. Whether the API has the employers and countries you need. Arbeitnow's German focus and JOA's German filter are not comparable to a US-only source.

• Freshness. How quickly a new role appears, or a closed one disappears, over days. You would need to repeat the request over time.

• Licence. What you may do with the rows. Adzuna requires an attribution label, Remotive delays jobs by 24 hours and bars passing them on to some sites, and several vendors bar competing data products. Read the terms.

• Price at your volume. Free tiers are for testing. Convert each vendor's price to a cost per 1,000 rows you will actually use.

Adding the sources that need sign-up

JSearch, Adzuna and TheirStack all publish free tiers, but they need an account first, so I did not include them in the script. To add one: sign up, read its docs for the search endpoint, write a function that returns rows in the same row(...) shape, and add it to the list in __main__. The summary logic does the rest. Their free-tier limits as published on 3 October 2026: JSearch 200 requests a month, TheirStack 200 API credits a month, Adzuna 2,500 requests a month by default.

Which would I pick?

This is my own conclusion from these measurements and my reading of each vendor's pages, and I build one of the seven, so check it against your own test.

• For employer-direct postings, a job board or an AI agent that must not recommend closed roles: I would start with Job Opportunities API. In this request it was the only one of the seven whose rows carried a closure date and reason and a per-field published, inferred or absent marker, and 96% of its apply links went to an ATS application page. It is not free of problems: its salary fill was low (8% in this German sample), two of its 50 rows shared a title, company and location, and its coverage is smaller than the aggregators'.

• For one employer you already know: use that employer's own Greenhouse, Lever or Ashby board API. It is free and it is the source.

• For a quick prototype over board data: JSearch or Adzuna, within their terms.

• For hiring signals aimed at sales: TheirStack.

The longer guide linked below explains each of those choices, with dated sources.

Next steps

If you want the broader picture, with a use-case table and a "choose X if" for each vendor, I wrote a longer comparison: Best job posting APIs in 2026: how to choose. It is a separate piece, with its own structure and reasoning.

To repeat this test with Job Opportunities API, get a free key at jobopportunitiesapi.org; the free Explore plan needs no card, and the pricing page lists the current allowance. If you find a result in this tutorial that you think is wrong, tell me and I will correct it.

Counting live job postings is easy. Knowing which companies are hiring more and which roles just disappeared is more interesting, and most job feeds can't tell you the second part because a closed role simply vanishes.

The Job Opportunities API keeps postings after they leave their source, with a closure date and a reason. This post builds a small hiring tracker on top of that:

• a daily snapshot of each company's open-role count (so you can see movement over time),

• the roles posted in the last week,

• the roles that closed in the last week, with the closure reason,

• a rough "days listed" figure that is honest about where it came from.

If you have not used the API before, the first post in this pair covers getting a key, the client basics and pagination. This one builds on it. It uses three endpoints that work on the free Explore plan: /v1/companies/{slug}, /v1/jobs and /v1/jobs/closed. (Get a free key at /login, no card; the key goes in JOA_API_KEY.)

What "closed" means here

Each closed row has closed_at and closed_reason. The documentation is explicit about the reasons:

• expired_upstream: the ledger proved the vacancy dead (re-checked against the board listing or the job URL itself).

• not_seen: the role stopped appearing at its source for the grace period. Usually a closure, occasionally a careers site that broke.

• employer_closed / deadline_passed: stated by the employer itself, for roles listed through Erioun for Teams.

A role an employer merely paused or unlisted is not a closure. Keep that in mind: a closure means "gone from the source", not "filled".

The tracker

Save as hiring_tracker.py (only requests and the standard library):

"""Hiring tracker: which companies are hiring, and which roles are closing.

Runs on the free JOA Explore plan. Needs: Python 3.9+, `pip install requests`, key in JOA_API_KEY.
Each run spends: 1 record per company (the snapshot) + the rows you read from the two lists.
"""
import os
import random
import sqlite3
import statistics
import sys
import time
from datetime import date, datetime, timedelta, timezone

import requests

API = "https://api.jobopportunitiesapi.org"
WATCHLIST = ["spotify", "adyen", "zalando", "n26"]  # company slugs, see /v1/companies?q=
WINDOW_DAYS = 7
SAMPLE = int(os.environ.get("SAMPLE", "10"))  # rows read per list per company = records spent

session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['JOA_API_KEY']}"


def get(path, **params):
    for attempt in range(4):
        resp = session.get(API + path, params=params, timeout=30)
        if resp.status_code in (429, 503):
            time.sleep(int(resp.headers.get("Retry-After", 2 ** attempt)) + random.random())
            continue
        if resp.status_code == 402:
            sys.exit("This month's free records are spent. Wait for the 1st or upgrade.")
        if not resp.ok:
            sys.exit(f"{resp.status_code} {resp.json().get('message', resp.text)}")
        return resp
    sys.exit("Still rate limited after 4 tries.")


def ts(value):
    return datetime.fromisoformat(value.replace("Z", "+00:00"))


db = sqlite3.connect("hiring.db")
db.execute(
    "CREATE TABLE IF NOT EXISTS snapshot ("
    " day TEXT, slug TEXT, open_roles INTEGER, PRIMARY KEY (day, slug))"
)


def snapshot(slug):
    """Today's open-role count for one company (1 record), stored so tomorrow can diff against it."""
    company = get(f"/v1/companies/{slug}").json()["data"]
    today = date.today().isoformat()
    previous = db.execute(
        "SELECT day, open_roles FROM snapshot WHERE slug=? AND day<? ORDER BY day DESC LIMIT 1",
        (slug, today),
    ).fetchone()
    db.execute("INSERT OR REPLACE INTO snapshot VALUES (?,?,?)", (today, slug, company["open_roles"]))
    db.commit()
    return company, previous


def days_listed(job):
    """Whole days between the posting and its closure.

    Use the employer's own posted_at when the field is 'published'; otherwise fall back to
    first_seen_at (when the ledger first saw it), which can only under-count.
    """
    start = job["posted_at"] if job["field_sources"].get("posted_at") == "published" else job["first_seen_at"]
    return max((ts(job["closed_at"]) - ts(start)).days, 0)


def report(slug):
    since = (datetime.now(timezone.utc) - timedelta(days=WINDOW_DAYS)).strftime("%Y-%m-%dT%H:%M:%SZ")
    company, previous = snapshot(slug)
    now = company["open_roles"]
    delta = f"{now - previous[1]:+d} since {previous[0]}" if previous else "first snapshot, no comparison yet"
    print(f"\n{company['name']}: {now} open roles ({delta})")

    fresh = get("/v1/jobs", company=slug, posted_after=since, limit=SAMPLE).json()
    more = "+" if fresh["has_more"] else ""
    print(f"  posted in the last {WINDOW_DAYS} days: {len(fresh['data'])}{more}")
    for job in fresh["data"][:3]:
        print(f"    + {job['title'][:60]}")

    closed = get("/v1/jobs/closed", company=slug, closed_after=since, limit=SAMPLE).json()
    more = "+" if closed["has_more"] else ""
    print(f"  closed in the last {WINDOW_DAYS} days: {len(closed['data'])}{more}")
    for job in closed["data"][:3]:
        print(f"    - {job['title'][:52]}  [{job['closed_reason']}, listed ~{days_listed(job)}d]")
    if closed["data"]:
        median = statistics.median(days_listed(j) for j in closed["data"])
        print(f"  median days listed (sample of {len(closed['data'])}): {median}")


if __name__ == "__main__":
    for slug in WATCHLIST:
        report(slug)
    spent = get("/v1/me").json()
    print(f"\nplan={spent['plan']}")

Find slugs with /v1/companies?q=<name>. The ones above are real company slugs in the ledger.

Real output

spotify: 84 open roles (first snapshot, no comparison yet)
  posted in the last 7 days: 9
    + Partner Manager - Lifestyle & Wellness
    + Program Manager - Podcast Sales Strategy & Solutions
    + Senior Software Engineer
  closed in the last 7 days: 10+
    - Security Engineer - Detection and Response  [not_seen, listed ~7d]
    - C++ Engineer - Experience  [not_seen, listed ~27d]
    - Marketing Technology Manager  [not_seen, listed ~75d]
  median days listed (sample of 10): 28.0

Adyen: 68 open roles (first snapshot, no comparison yet)
  posted in the last 7 days: 10+
    + Team Lead - Technical Support
    + Finance Support Specialist
    + Implementation Engineer
  closed in the last 7 days: 10+
    - Senior System Administrator [Storage Engineer]  [not_seen, listed ~127d]
    - Account Manager  [not_seen, listed ~318d]
    - Senior System Administrator [Ceph Engineer]  [not_seen, listed ~127d]
  median days listed (sample of 10): 78.5

Zalando: 93 open roles (first snapshot, no comparison yet)
  posted in the last 7 days: 2
    + Senior Applied Scientist (all genders)
    + Prozessmanager (all genders) Warehouse Operations Lahr
  closed in the last 7 days: 10+
    - Senior ML Software Engineer - Growth & Lifecycle / L  [not_seen, listed ~65d]
    - Creator Manager - Sports (all genders)  [not_seen, listed ~45d]
    - Senior Principal Product Manager – Client Foundation  [not_seen, listed ~89d]
  median days listed (sample of 10): 59.5

N26: 45 open roles (first snapshot, no comparison yet)
  posted in the last 7 days: 9
    + Head of Business Internal Audit
    + Senior Associate Audit & Operations
    + Steuerberater (Tax Manager)
  closed in the last 7 days: 10+
    - Backend Engineer - Investments & Savings  [not_seen, listed ~98d]
    - Senior Cloud Security Engineer  [not_seen, listed ~67d]
    - iOS Engineer - Digital Identity  [not_seen, listed ~56d]
  median days listed (sample of 10): 42.0

plan=explore

(A 10+ means the sample cap was hit. Raise SAMPLE if you want more rows and have the records to spend.)

Details that make it more honest

Days listed uses provenance. Every row carries field_sources. When posted_at is published, the employer's own date is used. Otherwise the code falls back to first_seen_at (when the ledger first saw the role), which can only under-count. The fallback is stated in the docstring so nobody mistakes the median for a measured time-to-fill. It is a rough indicator over a sample, nothing more.

The delta column needs a second day. The first run has nothing to compare against, so it says so. To check the diff logic, I edited a snapshot row for yesterday by hand and re-ran: the output read 84 open roles (+4 since <yesterday>). From the second real day on, you get the movement for free.

Staying inside the free allowance

On Explore, one row returned is one record, and the allowance is 1,000 a month. With four companies and SAMPLE=10, one run costs at most 4 x (1 + 10 + 10) = 84 records, so a weekly run uses roughly a third of the month. The key lever is SAMPLE: reading three rows instead of ten per list makes a run a handful of records. /v1/me shows your usage and costs nothing.

Schedule it with cron:

0 7 * * 1  cd /home/me/tracker && JOA_API_KEY=... python3 hiring_tracker.py >> weekly.txt

Limits to be upfront about

• Closure is evidence, not proof of a filled role. Companies close and repost roles all the time.

• not_seen can occasionally mean a company's careers page was down. Look at several closures at one company before reading anything into it.

• Coverage differs by country and by how an employer publishes jobs. Check the facts page for the markets you care about.

If you outgrow it

Re-querying works fine for a small watchlist. If you track many companies, the delta feed (/v1/changes) returns only what changed since your last call (created, updated, withdrawn, delisted), so you stop paying records to re-read unchanged rows. It is on the Growth plan and up, see pricing. There is also a keyless, beta /public/companies/{slug}/open-roles-history endpoint with a daily open-roles series per company. The history only started recently, so treat it as thin for now.

If you build something with this, or find a number that looks wrong, tell me in the comments.

If you have ever needed European job postings as data (for a dashboard, a research project, a job board, or just to see what a market looks like), you know the usual options: scrape career pages yourself, or buy a feed that is a mix of aggregator copies.

This post uses the Job Opportunities API (JOA), which serves postings taken from employers' own career sites and applicant-tracking systems. We will write a small Python client that:

• authenticates with a free key,

• filters by country, remote status and recent date,

• pages through results with the API's cursor,

• uses the per-field provenance tags to ask for salaries the employer actually published,

• writes a CSV, and

• stays inside the free record allowance.

Step 0 - look before you sign up

The statistics endpoints need no key and no account. This gives you the shape of the data (coverage per country, freshness, which sources feed it):

curl https://api.jobopportunitiesapi.org/public/coverage
curl https://api.jobopportunitiesapi.org/public/coverage/countries

Coverage is not uniform across countries, and the report says so openly, so check the countries you care about before building on them. The numbers are live, which is why I am not quoting any here: the always-current version is on the facts page.

Step 1 - get a free key

Sign in with your email at jobopportunitiesapi.org/login, click the link it sends, and press Create a free key on the dashboard. There is no password and no card. The free Explore plan has a monthly record allowance rather than a trial period, so it does not expire (plans and limits).

export JOA_API_KEY='paste-your-key-here'
curl -s -H "Authorization: Bearer $JOA_API_KEY" https://api.jobopportunitiesapi.org/v1/me

/v1/me tells you the plan, the rate limits and today's usage, and it costs no records. Useful to know early: one row returned = one record, so while exploring, keep limit small.

Step 2 - the client

Save this as joa_europe_jobs.py (it needs only requests):

"""Pull European job postings from the Job Opportunities API (JOA) with Python.

Needs: Python 3.9+, `pip install requests`, and a free Explore key in JOA_API_KEY.
"""
import csv
import os
import random
import sys
import time
from datetime import date, timedelta

import requests

API = "https://api.jobopportunitiesapi.org"
# EU27 + EFTA + UK as ISO-3166 alpha-2 codes; the API accepts a comma-separated list.
EUROPE = (
    "AT,BE,BG,HR,CY,CZ,DK,EE,FI,FR,DE,GR,HU,IE,IT,LV,LT,LU,MT,NL,PL,PT,RO,SK,SI,ES,SE,"
    "IS,LI,NO,CH,GB"
)

session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['JOA_API_KEY']}"
session.headers["Accept"] = "application/json"


def get(path, **params):
    """GET with the retry rule from the docs: retry 429/503 after Retry-After, never retry 402."""
    for attempt in range(4):
        resp = session.get(API + path, params=params, timeout=30)
        if resp.status_code in (429, 503):
            wait = int(resp.headers.get("Retry-After", 2 ** attempt))
            time.sleep(wait + random.random())  # jitter
            continue
        if resp.status_code == 402:
            sys.exit("This month's free records are spent. Wait for the 1st or upgrade.")
        if not resp.ok:  # the API explains itself: {"error": ..., "message": ...}
            sys.exit(f"{resp.status_code} {resp.json().get('message', resp.text)}")
        return resp
    sys.exit("Still rate limited after 4 tries.")


def iter_jobs(max_rows=25, page_size=25, **filters):
    """Walk /v1/jobs with the keyset cursor, stopping after max_rows (each row is one record)."""
    cursor, seen = None, 0
    while seen < max_rows:
        params = dict(filters, limit=min(page_size, max_rows - seen))
        if cursor:
            params["cursor"] = cursor
        resp = get("/v1/jobs", **params)
        body = resp.json()
        for job in body["data"]:
            yield job
            seen += 1
        if not body["has_more"]:
            break
        cursor = body["next_cursor"]
    left = resp.headers.get("x-ratelimit-records-remaining")
    print(f"  (records left this month: {left})", file=sys.stderr)


def provenance(job, field):
    """Where did this field come from? published / inferred / absent."""
    return job["field_sources"].get(field, "absent")


if __name__ == "__main__":
    me = get("/v1/me").json()  # costs no records
    print(f"plan={me['plan']} per_minute={me['limits']['per_minute']} per_day={me['limits']['per_day']}")

    week_ago = (date.today() - timedelta(days=7)).isoformat()

    print("\n== Remote data-engineering roles in Europe, last 7 days ==")
    rows = []
    for job in iter_jobs(
        max_rows=10,
        country=EUROPE,
        remote="remote",
        title="data engineer",
        posted_after=week_ago,
    ):
        rows.append(job)
        print(f"{job['country']}  {job['title'][:48]:<48}  {job['company'][:28]:<28}  "
              f"remote={provenance(job, 'remote')}")

    print("\n== Roles where the employer itself published the salary ==")
    for job in iter_jobs(
        max_rows=6,
        country="DE,FR,NL,IE,ES,IT",
        has_salary="true",
        require_fields="salary",
        title="engineer",
    ):
        lo, hi = job["salary_min"], job["salary_max"]
        print(f"{job['country']}  {job['title'][:44]:<44}  {lo}-{hi} {job['salary_currency']}/{job['salary_period']}")

    with open("european_jobs.csv", "w", newline="", encoding="utf-8") as fh:
        writer = csv.writer(fh)
        writer.writerow(["title", "company", "country", "city", "remote", "posted_at", "apply_url"])
        for job in rows:
            writer.writerow([job["title"], job["company"], job["country"], job.get("city", ""),
                             job["remote"], job["posted_at"], job["apply_url"]])
    print(f"\nwrote european_jobs.csv with {len(rows)} rows")

A few choices worth explaining:

• Cursor pagination. /v1/jobs is keyset-paginated: every response carries next_cursor and has_more, and you pass the cursor back. There are no offsets, so rows that appear while you page can't shift your window.

• Retries follow the docs. Retry 429 and 503 after Retry-After (with jitter), and never retry 402, which means the month's records are spent.

• Errors explain themselves. The API replies with {"error": ..., "message": ...}, and the client prints the message. I found this out the hard way, see the gotcha below.

Step 3 - run it

pip install requests
python joa_europe_jobs.py

This is the real output from my run (yours will differ, since the data moves every day):

plan=explore per_minute=30 per_day=5000

== Remote data-engineering roles in Europe, last 7 days ==
FR  Data Engineer - Transport - Nantes                Sopra Steria                  remote=published
EE  Senior Backend Engineer - Data Core (remote, Eur  Modash                        remote=published
FR  Senior Software Engineer - Data Search (remote,   Modash                        remote=published
HR  Data / DevOps Engineer (m/f)                      solvership                    remote=inferred
DE  Senior Data Platform Engineer (m/w/d) | Snowflak  Jobrad Loop                   remote=inferred
FR  Finance Data Engineer                             Voodoo                        remote=published
FR  Stage - Data Engineer - Aeroline - Toulouse       Sopra Steria                  remote=inferred

== Roles where the employer itself published the salary ==
IT  Field Automation Engineer                     28000-35000 EUR/year
IT  Junior Digital Verification Engineer          35000-40000 EUR/year
DE  QA Engineer (gn)                              55000-75000 EUR/year
IT  SALES ENGINEER (m/f/d)                        43000-50000 EUR/year
IT  PROGRAMMATORE PLC / AUTOMATION SOFTWARE ENGI  35000-45000 EUR/year
IT  Data Engineer – Cloud & AI Solutions          33000-40000 EUR/year

wrote european_jobs.csv with 7 rows

Provenance: why remote=published matters

Every row has a field_sources object that tags each field as published (the employer stated it), inferred (derived by the ledger, for example from the title or location) or absent. Look at the first query above: some roles are remote=published, others remote=inferred. If you are building something where a wrong "remote" label is costly, you can now filter on it, and the second query shows the server-side version of the same idea: require_fields=salary returns only rows where the salary came from the employer, not from a guess.

Gotchas I hit while testing

• require_fields accepts a fixed set of fields (description, employment_type, location, posted_at, remote, salary, source_type). My first attempt used salary_currency and got a clear 422 bad_require_fields listing the valid ones. That is why the client prints the API's message.

• title= searches the job title only. q= searches title, company and location, and description_contains= searches the advert body. Pick the narrowest one.

• Structured salaries are a small share of postings in most markets, so a salary-filtered query returns far fewer rows than an unfiltered one. That is expected, not a bug.

• This is not a census of every vacancy. Employers with public career pages are better represented than those without.

Where to go next

• Roles that have left their source are kept with a closure date and reason: /v1/jobs/closed. I use it in the follow-up post, tracking which companies are hiring and which roles are closing.

• If you work with AI agents, there is an MCP connector, so an agent can query the same data without you writing a client.

• The full parameter list is generated from the OpenAPI spec: docs.

• When 1,000 records a month is not enough, paid plans start at EUR 29/month: pricing.

If you hit a rough edge, tell me in the comments. It is one person's product and I read everything.