Reading Workday and Rippling job boards without a scraper (and the pagination trap)
I added Workday and Rippling to my jobs monitor by reading their job-list responses directly. The useful discovery was not just the endpoints. It was a pagination detail that could make a working Workday integration stop
I added Workday and Rippling to my jobs monitor by reading their job-list responses directly. The useful discovery was not just the endpoints. It was a pagination detail that could make a working Workday integration stop early while reporting success. My saved second page contained twenty jobs and a total of zero. Treating that zero as the end of the board would have discarded valid results.
Everything below is what I observed on real boards while building that integration. Neither endpoint is a documented public API, so treat this as a starting point: it can change, and another employer's board may behave differently.
Workday: start with the public board URL
My Workday example starts with NVIDIA's public board address. Its hostname supplies two pieces: nvidia is the tenant and wd5 is the cluster. The path supplies the site, NVIDIAExternalCareerSite. A locale such as en-US can appear before the site; I remove that segment rather than accidentally treating the locale as the board identifier.
Those pieces produce a different path on the same hostname: /wday/cxs/nvidia/NVIDIAExternalCareerSite/jobs. My implementation sends a POST with a JSON body containing appliedFacets, limit, offset, and searchText. In the example, the facets object and search text are empty. I request twenty records at a time, starting at offset zero.
I keep the tenant, cluster, and site separate because a single company name is insufficient to construct this address. The example checks the hostname and expects a board URL, rather than accepting an arbitrary job-detail path. The production integration also accepts a compact tenant/wdN/site identifier and normalizes it to the same company identity.
The pagination trap
My saved first response reports a total of 2,000 and contains twenty postings. The second response, requested at offset twenty, also contains twenty postings, but its total is zero. Together, the fixtures contain forty distinct job paths.
I preserve the first response's total instead of replacing it on every page. I advance the offset by the number of records returned. I also stop on a short page, a page that adds no new job paths, or the initial reported total when it is positive. A separate page cap keeps the example bounded.
Twenty is the page size used by this integration and exercised by these fixtures. I keep that limit explicit rather than assuming a larger request will return more records. The two-page example deliberately stops after forty observed postings; it does not download all 2,000 reported jobs. Its max-pages stop reason makes that limitation visible.
Here is the standalone example I tested. It uses built-in fetch, so I run it with Node.js 22 as an .mjs file. Running it normally makes requests; my verification substitutes fixture responses instead.
const board = new URL('https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite');
const match = /^([a-z0-9-]+)\.(wd[0-9]+)\.myworkdayjobs\.com$/.exec(board.hostname);
if (!match) throw new Error('Unsupported Workday hostname');
const [, tenant, cluster] = match;
const parts = board.pathname.split('/').filter(Boolean);
if (/^[a-z]{2}-[a-z]{2}$/i.test(parts[0])) parts.shift();
if (parts.length !== 1) throw new Error('Expected a board URL');
const site = parts[0];
const endpoint = `https://${tenant}.${cluster}.myworkdayjobs.com/wday/cxs/${tenant}/${encodeURIComponent(site)}/jobs`;
const jobs = [];
const seen = new Set();
const maxPages = 2; // Deliberate request cap, not a complete-board guarantee.
let offset = 0, totalReported = null, pagesFetched = 0;
let stopReason = 'max-pages';
for (let page = 0; page < maxPages; page++) {
const response = await fetch(endpoint, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ appliedFacets: {}, limit: 20, offset, searchText: '' }),
});
if (!response.ok) throw new Error(`Workday HTTP ${response.status}`);
const data = await response.json();
if (!Array.isArray(data.jobPostings) || !Number.isInteger(data.total) || data.total < 0 || data.jobPostings.length > 20) throw new Error('Unexpected Workday response');
if (totalReported === null) totalReported = data.total;
pagesFetched++;
let added = 0;
for (const job of data.jobPostings) {
if (!seen.has(job.externalPath)) { seen.add(job.externalPath); jobs.push(job); added++; }
}
offset += data.jobPostings.length;
if (data.jobPostings.length < 20) { stopReason = 'short-page'; break; }
if (!added) { stopReason = 'repeated-page'; break; }
if (totalReported > 0 && jobs.length >= totalReported) { stopReason = 'reported-total'; break; }
}
console.log(JSON.stringify({ jobs, totalReported, pagesFetched, stopReason }));
One habit that paid off: keep the records and the collection status separate. The forty paths are what I collected, the preserved total is what the first response claimed, and the stop reason says why I stopped. Hitting my own page cap is not evidence that the board has no more jobs.
Dates I could not safely normalize
The Workday fixtures include postedOn labels such as βPosted Todayβ and βPosted Yesterday.β I did not find an absolute publication timestamp in those saved posting objects. Converting those labels into precise timestamps would require assumptions about capture time and timezone that the labels themselves do not supply.
I therefore leave publishedAt empty in my normalized records. I can still retain the job's title, location, and public path. For monitoring, I use that path as the identifier within the company board. Missing precision is preferable to a date that appears authoritative but was manufactured during normalization.
Rippling: one GET and an array
Rippling's saved response is simpler to traverse. My adapter requests /platform/api/ats/v1/board/rippling/jobs on api.rippling.com with GET and receives a top-level array. The local fixture contains 717 records. I iterate that array directly; there is no Workday-style offset loop in this example.
The fields I map are uuid, name, workLocation.label, department.label, and url. I keep missing optional labels as null. This describes the response I saved, not a promise that every Rippling board always returns a complete collection in one response. I validate the array shape before mapping it.
const company = 'rippling';
const endpoint = `https://api.rippling.com/platform/api/ats/v1/board/${encodeURIComponent(company)}/jobs`;
const response = await fetch(endpoint);
if (!response.ok) throw new Error(`Rippling HTTP ${response.status}`);
const jobs = await response.json();
if (!Array.isArray(jobs)) throw new Error('Expected a Rippling job array');
console.log(JSON.stringify(jobs.map(job => ({
id: job.uuid, title: job.name, location: job.workLocation?.label ?? null,
department: job.department?.label ?? null, url: job.url ?? null,
}))));
What I verified, and what stayed unconfirmed
Both snippets are covered by tests that replay saved responses: the Workday one checks the POST body, the offsets, the preserved total and the two-page stop, and the Rippling one checks the endpoint and the mapped fields.
BambooHR did not reach the same standard of evidence. My six recorded requests produced four HTTP 302 responses and two empty JSON lists. I followed no redirects and made no retries. I exhausted the request allowance without obtaining a positive jobs fixture, so I left BambooHR out. These results do not establish that BambooHR cannot be read; they establish that I could not confirm it in this investigation.
I have incorporated the Workday and Rippling handling into New Jobs Monitor on Apify. The implementation is also available in its public GitHub repository.
Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.