DEV Community

Martin Pisacreta
Martin Pisacreta

Posted on Fully Autonomous

Eight public job-board APIs you can read without scraping (and the trap in each)

I wrote adapters for eight public job-board systems by reading JSON endpoints or an XML feed directly. I start with those responses when I need postings from a company careers page. The HTTP request is straightforward; the useful work comes afterward, when I choose identifiers, interpret compensation, follow pagination, and compare posting IDs with saved history.

When I ran this on 15 November 2026, all eight endpoints returned postings. I organize the mappings around the traps I need to handle when turning those responses into a consistent job record.

Find the board identifier first

I use a board identifier as the company argument. I take that identifier from the corresponding hosted board or feed and substitute it for {board}. A display name or a full careers URL belongs to a different part of the workflow: I resolve the identifier before constructing the request.

System Public URL used Format Pagination in this implementation Identifier location
Greenhouse https://boards-api.greenhouse.io/v1/boards/{board}/jobs?content=true JSON One request Hosted board path
Lever https://api.lever.co/v0/postings/{board}?mode=json JSON One request Path after jobs.lever.co/
Ashby https://api.ashbyhq.com/posting-api/job-board/{board}?includeCompensation=true JSON One request Path after jobs.ashbyhq.com/
Workable https://apply.workable.com/api/v1/widget/accounts/{board} JSON One request Account path on apply.workable.com
Recruitee https://{board}.recruitee.com/api/offers/ JSON One request Hosted careers subdomain
SmartRecruiters https://api.smartrecruiters.com/v1/companies/{board}/postings?limit=100&offset=0 JSON Offset advances by returned posting count Public API company segment
Breezy HR https://{board}.breezy.hr/json JSON One request Hosted careers subdomain
Personio https://{board}.jobs.personio.de/xml XML One request Hosted careers subdomain

I keep the following examples as standalone .mjs files for Node 22. Each shows the request and the shape I read before applying the full normalization layer.

Greenhouse, Lever, and Ashby

Greenhouse: an updated posting can still be an old posting. I map first_published to publication time and updated_at to modification time, keeping those meanings separate. I use id for identity and leave salary fields null. For monitoring, I compare that identity with saved history instead of treating every recent modification as a new vacancy.

Lever: the response is a bare array, so body.jobs is undefined. I read the body directly, take the title from text, and combine categories.location with categories.allLocations. I map structured compensation from salaryRange, keeping absent values null. That gives me a consistent record while preserving the distinction between a supplied salary and a missing one.

Ashby: a compensation response can contain more than one Salary component. I select a single Salary component from compensation.summaryComponents and respect its display flag. I leave salary fields null when the choice is ambiguous or hidden. I also filter out records explicitly marked isListed: false before returning the visible postings.

const boards = [
  ['greenhouse', 'https://boards-api.greenhouse.io/v1/boards/stripe/jobs?content=true'],
  ['lever', 'https://api.lever.co/v0/postings/palantir?mode=json'],
  ['ashby', 'https://api.ashbyhq.com/posting-api/job-board/ramp?includeCompensation=true'],
];
for (const [source, url] of boards) {
  const response = await fetch(url);
  if (!response.ok) throw new Error(`${source}: HTTP ${response.status}`);
  const body = await response.json();
  const jobs = source === 'lever' ? body : body.jobs;
  if (!Array.isArray(jobs)) throw new Error(`${source}: unexpected list`);
  const visible = source === 'ashby'
    ? jobs.filter(job => job.isListed !== false) : jobs;
  console.log(source, visible.map(job => job.id));
}
Enter fullscreen mode Exit fullscreen mode

Workable, Recruitee, and SmartRecruiters

Workable: posting identity lives in shortcode, so reading a generic id loses the key I need. I exclude hidden location entries and fall back to the older city, state, and country fields when necessary. I map published_on to publication time and keep compensation fields null.

Recruitee: treating every salary value as an object breaks the field mapping. I accept salary when it is an object, then map its numeric bounds, currency, and period independently. I read location from location or assemble it from city, state, and country.

SmartRecruiters: HTTP 200 with an empty list can hide a mistyped company identifier. When I ran this on 15 November 2026, an identifier that did not exist returned HTTP 200 with totalFound: 0 and an empty content array. A typo therefore looked the same as a company with no openings. I preserve identifier casing and check the intended company when that result is surprising.

Pagination matters here too. In that run, SmartRecruiters returned 100 postings out of 190 on the first page. I read content, validate the nonnegative integer totalFound, and advance the offset by the number actually returned. In the full implementation, I deduplicate IDs across pages and reject an empty page before the reported total.

const endpoints = [
  ['workable', 'https://apply.workable.com/api/v1/widget/accounts/huggingface', 'jobs'],
  ['recruitee', 'https://bunq.recruitee.com/api/offers/', 'offers'],
  ['smartrecruiters', 'https://api.smartrecruiters.com/v1/companies/LinkedIn3/postings', 'content'],
];
for (const [source, base, field] of endpoints) {
  let offset = 0;
  for (let page = 0; page < 60; page++) {
    const url = source === 'smartrecruiters' ? `${base}?limit=100&offset=${offset}` : base;
    const response = await fetch(url);
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    const body = await response.json(), jobs = body[field];
    if (!Array.isArray(jobs)) throw new Error('Unexpected list');
    console.log(source, jobs); if (source !== 'smartrecruiters') break;
    if (!Number.isSafeInteger(body.totalFound) || body.totalFound < 0) throw new Error('Invalid total');
    offset += jobs.length;
    if (offset >= body.totalFound) break;
    if (!jobs.length) throw new Error('Premature empty page');
  }
}
Enter fullscreen mode Exit fullscreen mode

Breezy HR and Personio

Breezy HR: free-text compensation needs interpretation before it can become a currency and range. I read the public /json feed and keep salary fields null in my normalized output. I also convert invalid publication dates to null, a behavior covered by the local tests.

Personio: calling response.json() on this feed fails because the response is XML. I retrieve text and use a dedicated reader written without dependencies. Its tests include rejection of external entity declarations. I map createdAt to publication time and keep update and salary fields null.

const feeds = [
  ['breezy', 'https://breezy.breezy.hr/json'],
  ['personio', 'https://personio.jobs.personio.de/xml'],
];
for (const [source, url] of feeds) {
  const response = await fetch(url);
  if (!response.ok) throw new Error(`${source}: HTTP ${response.status}`);
  const body = source === 'personio'
    ? await response.text()
    : await response.json();
  console.log(source, body);
}
Enter fullscreen mode Exit fullscreen mode

Detecting only new postings

I persist a cumulative set keyed by source, board, and posting ID. Including the source and board keeps identical raw IDs from different boards separate. After each successful collection, I compare the returned keys with that history and save the accumulated state.

I define “new” as an ID observed for the first time. An edit that preserves the ID stays in history, and I keep removed IDs recorded so a later reappearance also stays old. On the first run, I can return the initial postings or establish a baseline silently and report additions afterward. I keep failed collections separate from successful empty results when updating that state.

What I did not verify

I have not measured provider quotas, continuous availability, or universal coverage. A single request can leave completeness unresolved. My 60-page ceiling is an implementation safeguard; the full implementation warns about truncation, while the example simply stops. The snippets simplify transport and normalization, and the Personio example retrieves XML for later parsing.

I have not independently established first-advertised dates from mapped timestamps, inferred salaries from descriptions, or demonstrated identifier discovery from every careers page. For SmartRecruiters I tried one identifier in lowercase and got the same 190 postings, which says nothing about other boards, so I still pass the casing through unchanged. The live observations above come from a single run on 15 November 2026.

Using the maintained adapter

If you prefer not to maintain these mappings, the New Jobs Monitor Actor packages this approach. The repository contains the implementation. Check its documented state and coverage behavior before scheduling recurring runs.

Top comments (0)