You usually don't have to. Almost every careers page is hosted on an applicant tracking system (ATS): Greenhouse, Lever, Ashby, Workday and a handful of others. Nearly all of them expose the job list as public JSON, either an official API meant for embedding job boards, or the same endpoint the career site itself calls. No login, no API key, no CAPTCHAs.

This post shows how to read four of them with plain requests, plus the gotchas I hit while mapping a dozen of them.

Step 1: figure out which ATS a company uses

Open the careers page and look at where the "Apply" links go:

If the careers page is on the company's own domain, view the page source and search for greenhouse, lever.co, ashbyhq or myworkdayjobs. The board URL is almost always in there.

Step 2: Greenhouse

Greenhouse has an official, documented Job Board API:

import requests

def greenhouse(slug):
    url = f"https://boards-api.greenhouse.io/v1/boards/{slug}/jobs"
    jobs = requests.get(url, params={"content": "true"}, timeout=30).json()["jobs"]
    return [{"title": j["title"], "location": j["location"]["name"], "url": j["absolute_url"]}
            for j in jobs]

print(len(greenhouse("airbnb")))  # 186 open jobs when I ran it

Gotcha: with content=true you get the full description, but it's HTML-escaped (<p>), so run it through html.unescape() before parsing. Remote/hybrid isn't a standard field either. It only exists if the company added a custom metadata field.

Step 3: Lever

def lever(slug):
    for host in ("api.lever.co", "api.eu.lever.co"):  # EU companies live on a separate host
        r = requests.get(f"https://{host}/v0/postings/{slug}", params={"mode": "json"}, timeout=30)
        if r.ok and r.json():
            return [{"title": j["text"], "location": j["categories"].get("location"),
                     "url": j["hostedUrl"]} for j in r.json()]
    return []

print(len(lever("spotify")))  # 82

Gotchas: EU-hosted companies only answer on api.eu.lever.co, so try both. Dates (createdAt) are epoch milliseconds.

Step 4: Ashby (best salary data)

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

print(ashby("ramp")[0])
# {'title': 'Security Engineer, Cloud', 'location': 'New York, NY (HQ)', 'remote': True,
#  'salary': '$211.4K – $290.6K • Offers Equity', ...}

Ashby has the most structured compensation data of any ATS I've looked at: there are also numeric min/max/currency fields under compensation.

Step 5: Workday (where it gets interesting)

Big companies like NVIDIA, Salesforce and many banks use Workday. There's no official public API, but the career site loads its jobs from a JSON endpoint you can call the same way:

def workday(host, tenant, site, search=""):
    url = f"https://{host}/wday/cxs/{tenant}/{site}/jobs"
    body = {"appliedFacets": {}, "limit": 20, "offset": 0, "searchText": search}
    first = requests.post(url, json=body, timeout=30).json()
    return first["total"], first["jobPostings"]

total, page = workday("nvidia.wd5.myworkdayjobs.com", "nvidia", "NVIDIAExternalCareerSite")
print(total)  # 2000

That 2000 is a lie: NVIDIA had 2,747 open jobs when I ran this. Workday's gotchas:

• Max 20 results per page.
• Every search stops at 2,000 results. Past offset 2,000 it silently wraps back to page 1, so a naive pager loops forever or returns duplicates.
• The workaround is to split the search by a facet: the response includes facets (job category, location…), and if you pick one whose biggest bucket is under 2,000 and page through each value separately, you get everything.
• total is only reliable on the first page.
• It's behind Cloudflare and throttles per IP, so keep concurrency around 2 and back off on HTTP 429.

The other ATSs, briefly

Be a good citizen: these feeds are public because companies want their jobs distributed, but cache results, don't hammer them, and respect 429s.

The hard part is normalizing

Each of these returns a different shape: locations as strings vs objects, dates as ISO strings vs epoch ms, salaries structured vs free text, remote flags in five different places. Writing the fetchers takes an afternoon. Keeping a dozen of them normalized and working as APIs change is the real work.

If you'd rather not maintain it

Disclosure: I packaged all twelve of these into an Apify actor that I built and maintain. You give it company names ("Ramp"), domains or careers URLs, and it detects the ATS and returns every job in one schema: title, location, remote/hybrid, salary min/max/currency, dates and full description. It also handles the Workday 2,000-result cap, and has a "new jobs only" mode for daily monitoring. It's pay-per-result ($2 per 1,000 jobs).

But everything above works fine on its own. Happy to answer questions about any of these endpoints in the comments.