Disclosure: I built the Apify actor used in the second half of this post. It is a paid tool (pay per job). The first half is free and uses only Greenhouse's and Lever's public APIs.

A large share of tech companies run their hiring on one of two applicant tracking systems: Greenhouse (Stripe, Airbnb, Figma, thousands more) or Lever (Palantir, Spotify and many startups). Both publish every open role through a free public JSON API, built so companies can show jobs on their own sites. No login, no API key, no HTML scraping.

That makes them the best source for:

  • Job boards and newsletters: clean, current jobs straight from the employer.
  • Sales prospecting: a company opening its first data-platform or SDR roles is a buying signal.
  • Recruiting and market research: which teams and cities a company is growing.

Find the board slug

Every company has a board slug. Open any job and look at the URL:

  • Greenhouse: boards.greenhouse.io/stripe or job-boards.greenhouse.io/figma/jobs/123 (slug: stripe, figma)
  • Lever: jobs.lever.co/palantir/... (slug: palantir)

If the careers page is on the company's own domain, click Apply on any job; the application form usually lives on one of the two hosts above.

The free way: Greenhouse

One request returns all of a company's jobs; there is no paging. Add content=true for descriptions, departments and offices, and pay_transparency=true for salary ranges:

import html import re from datetime import datetime, timezone import requests def clean(text): text = html.unescape(text or "") # Greenhouse sends its HTML escaped text = re.sub(r"<[^>]+>", " ", text) # then strip the tags return re.sub(r"\s+", " ", html.unescape(text)).strip() def greenhouse_jobs(board): r = requests.get( f"https://boards-api.greenhouse.io/v1/boards/{board}/jobs", params={"content": "true", "pay_transparency": "true"}, timeout=120, ) r.raise_for_status() jobs = [] for j in r.json()["jobs"]: pay = (j.get("pay_input_ranges") or [{}])[0] jobs.append({ "ats": "greenhouse", "company": j.get("company_name") or board, "title": j["title"].strip(), "department": ", ".join(d["name"] for d in j.get("departments", [])), "location": j["location"]["name"], "posted": (j.get("first_published") or j["updated_at"])[:10], "salary_min": pay["min_cents"] / 100 if pay.get("min_cents") else None, "salary_max": pay["max_cents"] / 100 if pay.get("max_cents") else None, "currency": pay.get("currency_type"), "url": j["absolute_url"], "description": clean(j.get("content")), }) return jobs figma = greenhouse_jobs("figma") print(len(figma), "Figma jobs,", sum(1 for j in figma if j["salary_min"]), "with a salary range") for j in figma[:3]: print(j["posted"], j["title"], "|", j["location"], "|", j["salary_min"], "-", j["salary_max"], j["currency"]) 

The free way: Lever

Lever's endpoint also returns everything in one request with mode=json, and already includes a plain-text description:

def lever_jobs(company): r = requests.get(f"https://api.lever.co/v0/postings/{company}", params={"mode": "json"}, timeout=120) r.raise_for_status() jobs = [] for p in r.json(): cat = p.get("categories", {}) pay = p.get("salaryRange") or {} jobs.append({ "ats": "lever", "company": company, "title": p["text"].strip(), "department": cat.get("department") or cat.get("team") or "", "location": cat.get("location", ""), "posted": datetime.fromtimestamp(p["createdAt"] / 1000, timezone.utc).date().isoformat(), "salary_min": pay.get("min"), "salary_max": pay.get("max"), "currency": pay.get("currency"), "url": p["hostedUrl"], "description": p.get("descriptionPlain", "").strip(), }) return jobs palantir = lever_jobs("palantir") print(len(palantir), "Palantir jobs") 

Merge both into one CSV

Because both functions return the same keys, combining companies from both systems is one loop:

import csv import time boards = [("greenhouse", "stripe"), ("greenhouse", "figma"), ("lever", "palantir"), ("lever", "spotify")] fetch = {"greenhouse": greenhouse_jobs, "lever": lever_jobs} rows = [] for ats, slug in boards: rows += fetch[ats](slug) time.sleep(1) # be polite cutoff = datetime.now(timezone.utc).date().toordinal() - 14 recent = [r for r in rows if datetime.fromisoformat(r["posted"]).toordinal() >= cutoff] with open("ats_jobs.csv", "w", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=[k for k in rows[0] if k != "description"], extrasaction="ignore") writer.writeheader() writer.writerows(recent) print(len(rows), "jobs in total,", len(recent), "posted in the last 14 days -> ats_jobs.csv") 

Things you will run into

  • updated_at is not the posting date. Greenhouse bumps it whenever a job is edited, and big employers edit many jobs at once: when I tested, 755 of Stripe's 778 jobs had an updated_at on the same day, including 586 first published months earlier. Use first_published for "new jobs", falling back to updated_at.
  • Greenhouse escapes its HTML. The content field arrives as &lt;p&gt;..., so unescape it before stripping tags, as clean() does.
  • Responses can be big. Stripe's board with content=true is about 6 MB in one response. Drop content=true if you only need titles and links.
  • Salaries only appear if the company enters them. With pay_transparency=true, Figma had a range on 94 of 147 jobs; Stripe had none. On Lever, salaryRange is rarer still. Never fill the gap with guesses.
  • A wrong slug returns 404 on both APIs, which at least tells you the slug is wrong.
  • There is no "new since last time" flag. For alerts, keep the job URLs you have already seen and compare on every run.

For a few companies now and then, this is all you need.

The hosted way: many boards, filters and hiring signals

Greenhouse & Lever Jobs Scraper is the Apify actor I built for this. It takes a list of boards from both systems, normalises them into one schema (including Greenhouse pay ranges and real first-published dates), cleans the descriptions, applies your filters, and can return only jobs it has not returned before. Each job also gets a rule-based hiring-signal score (0-100) with tags such as likely business needs and target buyer, meant for sales research.

You need a free Apify account and your API token (Console, then Settings, then API & Integrations). Then pip install "apify-client>=3" and run this. It finds account-executive roles at three companies:

import csv from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("sonic_scraper/hiring-signal-jobs-scraper").call(run_input={ "companySlugs": ["greenhouse:figma", "greenhouse:stripe", "lever:spotify"], "keywords": ["account executive"], "maxJobsPerCompany": 1000, "maxTotalJobs": 300, }) with open("sales_hiring.csv", "w", newline="", encoding="utf-8") as f: writer = csv.writer(f) writer.writerow(["ats", "company", "title", "department", "location", "posted", "salary_min", "salary_max", "currency", "per", "score", "tier", "url"]) for job in client.dataset(run.default_dataset_id).iterate_items(): writer.writerow([job["sourceAts"], job["companyName"], job["title"], job["department"], job["location"], (job["postedAt"] or "")[:10], job["salaryMin"], job["salaryMax"], job["salaryCurrency"], job["salaryInterval"], job["hiringSignalScore"], job["hiringSignalTier"], job["jobUrl"]]) print("Saved sales_hiring.csv") 

Other filters: locations, departments, seniorities (for example "Senior", "Director"), remoteOnly, postedWithinDays and minHiringSignalScore. You can also paste board URLs into careerUrls instead of slugs. Salary columns are filled when the company publishes a range; in this run, Figma's US roles had one (for example $165,000-190,000 a year for an enterprise AE) and Stripe's had none. per is year, month or hour.

keywords match the title, department, location or description, so prefer specific phrases: in my test run about two thirds of the rows had "account executive" in the title, and the rest were related sales roles that mention it in the text.

The signal score and tags are heuristics from the job text, not proof of budget or intent; always read the linked posting before you reach out.

A daily feed of new jobs

run = client.actor("sonic_scraper/hiring-signal-jobs-scraper").call(run_input={ "companySlugs": ["greenhouse:figma", "greenhouse:airbnb", "lever:palantir", "lever:spotify"], "departments": ["Data", "Engineering"], "monitorMode": True, "onlyNewJobs": True, "stateKey": "data-hiring-watch", "maxTotalJobs": 500, }) 

The first run returns everything that matches; after that, each run with the same stateKey returns only jobs it has not returned before, so a quiet day can legitimately return nothing. maxTotalJobs defaults to 100, so raise it for the first run on many boards. Save the input as a task in Apify Console, add a daily schedule, and send new rows to Slack, Google Sheets, a CRM or a webhook with an Apify integration, Make, Zapier or n8n.

What it costs

$3 per 1,000 jobs saved on the free plan ($0.003 per job), plus a tiny start fee per run. Jobs removed by your filters are not charged. A daily feed on 20 companies that returns 30 new jobs a day is about $2.70 a month. maxTotalJobs caps every run.

Honest limits

  • You choose the boards. Neither the APIs nor the actor search all of Greenhouse or Lever; you need each company's slug. Companies on Ashby, Workday or other systems are not covered.
  • Fields are whatever the company publishes. Departments, locations and salaries vary a lot between companies.
  • Only public postings. Internal jobs and candidate data are never available.
  • If you track a handful of companies, the free code above is enough. The actor is for many boards across both systems, filters, signal tags and scheduled new-job alerts without running your own server.

Links

Questions or a board that returns nothing? Leave a comment or open an issue on the actor's Issues tab. I read them daily.