DEV Community: Loukas Tzekos

Track which companies are hiring (and closing roles) with a jobs API

Loukas Tzekos — Sat, 03 Oct 2026 01:16:17 +0000

Disclosure: I build JOA, the jobs API used below. The code runs on its free plan and I tested it against the live API in early October 2026.

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.

Get European job postings from an API in Python in 5 minutes

Loukas Tzekos — Fri, 02 Oct 2026 23:05:50 +0000

Disclosure: I build JOA, the jobs API used below. Everything here works on its free plan, and I ran every snippet against the live API in early October 2026 before writing this.

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.