Get Greenhouse, Lever, Ashby and Workday jobs as one JSON feed

Cleanrows — Sun, 15 Nov 2026 12:54:43 +0000

If you build a job board, a hiring-signal tool, or a labour-market dataset, you hit the same wall: every company uses a different applicant tracking system, and each one returns jobs in its own shape.

Three of the four systems you will meet most often have public job-board endpoints. You can call them with no API key:

Greenhouse: https://boards-api.greenhouse.io/v1/boards/{board}/jobs (job board API docs)
Lever: https://api.lever.co/v0/postings/{company}
Ashby: https://api.ashbyhq.com/posting-api/job-board/{board}

Workday is the exception. Career sites on *.myworkdayjobs.com have no documented public API.

The Python 3 script below (standard library only) pulls Anthropic on Greenhouse, Spotify on Lever and Ramp on Ashby, maps each job onto one schema, and writes jobs.json. I ran it on 15 November 2026; it returned 935 jobs. Later in the post I show a shortcut I built, as Cleanrows, for adding Workday to the same schema.

The script

"""One JSON feed from the public Greenhouse, Lever and Ashby job APIs.

Standard library only. No API keys. Run: python3 one_json_jobs_feed.py
"""
import json
from datetime import datetime, timezone
from urllib.request import Request, urlopen

UA = {
    "User-Agent": "one-json-jobs-feed/1.0 (+https://dev.to/cleanrows)",
    "Accept": "application/json",
}


def get_json(url):
    request = Request(url, headers=UA)
    with urlopen(request, timeout=30) as response:
        return json.load(response)


def looks_remote(*parts):
    text = " ".join(p for p in parts if p).lower()
    return "remote" in text


def from_greenhouse(board):
    payload = get_json(f"https://boards-api.greenhouse.io/v1/boards/{board}/jobs")
    jobs = []
    for job in payload.get("jobs", []):
        location = (job.get("location") or {}).get("name")
        jobs.append({
            "company": job.get("company_name") or board,
            "ats": "greenhouse",
            "job_id": str(job["id"]),
            "title": (job.get("title") or "").strip(),
            "location": location,
            "is_remote": looks_remote(location),
            # Greenhouse exposes updated_at and first_published, but
            # first_published is not a reliable original posting date.
            "posted_at": None,
            "updated_at": job.get("updated_at"),
            "apply_url": job.get("absolute_url"),
        })
    return jobs


def from_lever(board):
    payload = get_json(f"https://api.lever.co/v0/postings/{board}")
    company = board[:1].upper() + board[1:]
    jobs = []
    for job in payload:
        categories = job.get("categories") or {}
        location = categories.get("location")
        if not location:
            location = ", ".join(categories.get("allLocations") or [])
        posted_at = None
        if job.get("createdAt"):
            posted_at = datetime.fromtimestamp(
                job["createdAt"] / 1000, tz=timezone.utc
            ).strftime("%Y-%m-%dT%H:%M:%S.000Z")
        workplace = job.get("workplaceType") or ""
        jobs.append({
            "company": company,
            "ats": "lever",
            "job_id": job["id"],
            "title": (job.get("text") or "").strip(),
            "location": location or None,
            "is_remote": workplace.lower() == "remote" or looks_remote(location),
            "posted_at": posted_at,
            "updated_at": None,
            "apply_url": job.get("applyUrl") or job.get("hostedUrl"),
        })
    return jobs


def from_ashby(board):
    # A User-Agent is required; without one Ashby often returns 403.
    payload = get_json(f"https://api.ashbyhq.com/posting-api/job-board/{board}")
    company = board[:1].upper() + board[1:]
    jobs = []
    for job in payload.get("jobs", []):
        location = job.get("location")
        jobs.append({
            "company": company,
            "ats": "ashby",
            "job_id": job["id"],
            "title": (job.get("title") or "").strip(),
            "location": location,
            "is_remote": bool(job.get("isRemote")) or looks_remote(location),
            "posted_at": job.get("publishedAt"),
            "updated_at": None,
            "apply_url": job.get("applyUrl") or job.get("jobUrl"),
        })
    return jobs


FETCHERS = {
    "greenhouse": from_greenhouse,
    "lever": from_lever,
    "ashby": from_ashby,
}

# Board tokens are the slug in the career-site URL:
# job-boards.greenhouse.io/anthropic, jobs.lever.co/spotify, jobs.ashbyhq.com/ramp
BOARDS = [
    ("greenhouse", "anthropic"),
    ("lever", "spotify"),
    ("ashby", "ramp"),
]


if __name__ == "__main__":
    feed = []
    for ats, board in BOARDS:
        jobs = FETCHERS[ats](board)
        print(f"{ats}:{board} -> {len(jobs)} jobs")
        feed.extend(jobs)

    with open("jobs.json", "w") as handle:
        json.dump(feed, handle, indent=2)

    print(f"\nWrote {len(feed)} jobs from {len({j['company'] for j in feed})} companies to jobs.json")
    print(f"{'ats':<11} {'company':<11} {'title':<48} location")
    # Show three jobs from each board
    shown = {}
    for job in feed:
        count = shown.get(job["ats"], 0)
        if count >= 3:
            continue
        shown[job["ats"]] = count + 1
        line = f"{job['ats']:<11} {job['company']:<11} {job['title'][:48]:<48} {job['location'] or ''}"
        print(line[:120])

The board token is the slug in the company's career-site URL: job-boards.greenhouse.io/anthropic, jobs.lever.co/spotify, jobs.ashbyhq.com/ramp. Swap those slugs to point the script at other companies.

What comes back

Output from the run on 15 November 2026:

greenhouse:anthropic -> 668 jobs
lever:spotify -> 87 jobs
ashby:ramp -> 180 jobs

Wrote 935 jobs from 3 companies to jobs.json
ats         company     title                                            location
greenhouse  Anthropic   3P Revenue Accounting & Reporting                San Francisco, CA | Seattle, WA
greenhouse  Anthropic   Account Executive, AI Native                     New York City, NY; San Francisco, CA | New York
greenhouse  Anthropic   Account Executive, Nonprofit                     San Francisco, CA | New York City, NY
lever       Spotify     Account Executive - Commercial, Spotify Technolo New York, NY
lever       Spotify     Account Executive - Commercial, Spotify Technolo London
lever       Spotify     Account Executive - Commercial, Spotify Technolo Toronto
ashby       Ramp        Software Engineer, Security, Cloud               New York, NY (HQ)
ashby       Ramp        Software Engineer, Android                       New York, NY (HQ)
ashby       Ramp        Account Executive | Strategic                    San Francisco, CA

One row from each ATS, taken from jobs.json:

{
  "company": "Anthropic",
  "ats": "greenhouse",
  "job_id": "5456619008",
  "title": "3P Revenue Accounting & Reporting",
  "location": "San Francisco, CA | Seattle, WA",
  "is_remote": false,
  "posted_at": null,
  "updated_at": "2026-10-19T11:17:24-04:00",
  "apply_url": "https://job-boards.greenhouse.io/anthropic/jobs/5456619008"
}

{
  "company": "Spotify",
  "ats": "lever",
  "job_id": "2a55d6c9-c564-443a-be3e-a3851db5a93b",
  "title": "Account Executive - Commercial, Spotify Technology",
  "location": "New York, NY",
  "is_remote": false,
  "posted_at": "2026-10-23T15:00:40.000Z",
  "updated_at": null,
  "apply_url": "https://jobs.lever.co/spotify/2a55d6c9-c564-443a-be3e-a3851db5a93b/apply"
}

{
  "company": "Ramp",
  "ats": "ashby",
  "job_id": "34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "title": "Software Engineer, Security, Cloud",
  "location": "New York, NY (HQ)",
  "is_remote": true,
  "posted_at": "2026-04-07T17:12:35.753+00:00",
  "updated_at": null,
  "apply_url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application"
}

Things the public APIs do not agree on

The responses are useful, but they are not interchangeable:

Envelope. Greenhouse and Ashby wrap jobs in {"jobs": [...]}. Lever returns a bare array.
User-Agent. Ashby's posting API often returns HTTP 403 if you omit a User-Agent header. Set one.
Company name. Greenhouse includes company_name. Lever and Ashby do not, so the script titles the board slug.
Dates. Lever's createdAt is a millisecond timestamp. Ashby has an ISO publishedAt. Greenhouse exposes updated_at and first_published, but I do not treat either as a reliable original posting date — on some jobs they are identical, on others they differ by years — so posted_at is left empty for Greenhouse.
Remote work. Ashby has an isRemote flag. Lever has workplaceType (remote, hybrid, onsite). Greenhouse usually leaves this in the location string or in metadata. The script uses a conservative rule: trust the flag or the word "remote".
Compensation. These list endpoints do not give a structured salary field I would trust, so the script does not invent one. Lever sometimes mentions a range in free text (additionalPlain); that is a separate parsing problem.
Titles. Ashby titles can have a leading space. The script strips whitespace.

Add more boards by appending to BOARDS. The usual next ones people ask for are Workable, SmartRecruiters and Recruitee, each with yet another payload shape, plus Workday, which has no public list API at all.

A shortcut for Workday, and for one maintained schema

I built two Apify Actors as Cleanrows that return the same schema the script above uses: ATS Jobs Feed (Greenhouse, Lever, Ashby, plus Workable, SmartRecruiters and Recruitee) and Workday Jobs Feed. You do not need them for the three public APIs. They are useful when you want Workday in the same feed, a company shorthand such as "greenhouse:anthropic", incremental runs that emit only new jobs, or a preset list such as ai-companies.

The snippet below needs an Apify token (Console → Settings → API & Integrations) and uses the same run-sync-get-dataset-items endpoint for both Actors. I ran it on 15 November 2026 with a cap of three jobs per company:

"""Optional shortcut: add Workday, keep one schema (Apify API, stdlib only)."""
import json, os, urllib.request

TOKEN = os.environ["APIFY_TOKEN"]


def run_actor(actor, run_input):
    url = (f"https://api.apify.com/v2/acts/{actor}/run-sync-get-dataset-items"
           "?clean=true")
    req = urllib.request.Request(
        url,
        data=json.dumps(run_input).encode(),
        headers={
            "Content-Type": "application/json",
            "Authorization": f"Bearer {TOKEN}",
        },
    )
    with urllib.request.urlopen(req, timeout=300) as resp:
        return json.load(resp)


ats_jobs = run_actor("henryklimes~ats-jobs-feed", {
    "companies": ["greenhouse:anthropic", "lever:spotify", "ashby:ramp"],
    "includeDescription": False,
    "maxJobsPerCompany": 3,
})

workday_jobs = run_actor("henryklimes~workday-jobs-feed", {
    "careerUrls": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"],
    "includeDescription": False,
    "maxJobs": 3,
})

FIELDS = ["company", "ats", "title", "location", "is_remote", "posted_at", "apply_url"]
feed = [{k: job.get(k) for k in FIELDS} for job in ats_jobs + workday_jobs]

with open("jobs.json", "w") as f:
    json.dump(feed, f, indent=2)

print(f"{len(feed)} jobs from {len({j['company'] for j in feed})} companies")
for job in feed:
    print(f"{job['ats']:<10} {job['company']:<10} {job['title'][:48]:<48} {job['location'] or ''}"[:120])

12 jobs from 4 companies
greenhouse Anthropic  3P Revenue Accounting & Reporting                San Francisco, CA | Seattle
greenhouse Anthropic  Account Executive, AI Native                     New York City, NY; San Francisco, CA | New York C
greenhouse Anthropic  Account Executive, Nonprofit                     San Francisco, CA | New York City
lever      Spotify    Account Executive - Commercial, Spotify Technolo New York
lever      Spotify    Account Executive - Commercial, Spotify Technolo London
lever      Spotify    Account Executive - Commercial, Spotify Technolo Toronto
ashby      Ramp       Software Engineer, Security, Cloud               New York, NY (HQ)
ashby      Ramp       Software Engineer, Android                       New York, NY (HQ)
ashby      Ramp       Account Executive | Strategic                    San Francisco
workday    Nvidia     Manager, Physical Design Circuit and Signoff CAD Israel, Yokneam
workday    Nvidia     Senior Formal Verification Engineer              Israel, Yokneam
workday    Nvidia     Software Engineer, AI Infrastructure             Israel, Tel Aviv

A Workday row from that run:

{
  "company": "Nvidia",
  "ats": "workday",
  "title": "Manager, Physical Design Circuit and Signoff CAD",
  "location": "Israel, Yokneam",
  "is_remote": false,
  "posted_at": "2026-11-15T00:00:00.000Z",
  "apply_url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/Israel-Yokneam/Manager--Physical-Design-Circuit-and-Signoff-CAD_JR2019878"
}

Both Actors are pay-per-result at $1.50 per 1,000 jobs, with no monthly fee. The 12 jobs above cost under 2 cents. A snapshot of 6,493 open postings at 39 AI and YC companies, which I ran on 15 November 2026, costs about $9.70 at that price. The company list is in this example task.

On large Workday boards the Actor splits the search using Workday's own facets (country, job family) so it can get past the roughly 2,000-result cap on a single search, then drops duplicates. Set "incrementalMode": true on either Actor and schedule it if you only want new postings on later runs.

In Apify Console you can save the input as a task, add a schedule, and send the dataset to Google Sheets, a webhook, Make, n8n or Zapier. Or call run-sync-get-dataset-items from cron, as in the snippet.

Try it

The script in the first section is enough to get a Greenhouse, Lever and Ashby feed today. Change the slugs in BOARDS and run it.
ATS Jobs Feed and Workday Jobs Feed if you want the shortcut, including Workday.
One-click example tasks: OpenAI jobs from Ashby, NVIDIA jobs from Workday.