DEV Community: Noble Ronin

Clinical Trials Data Has a Free JSON API — Every Study on ClinicalTrials.gov, No Key Required

Noble Ronin — Mon, 03 Aug 2026 06:47:49 +0000

If you've ever needed to know which drugs are in trial for a given condition, who's sponsoring a study, or whether a trial is still recruiting, you don't need to scrape the ClinicalTrials.gov website. The US National Library of Medicine runs an official v2 API over its registry of 500,000+ studies — free, public, and keyless. No sign-up, no token, no rate-limit tier to unlock.

The base

https://clinicaltrials.gov/api/v2/studies

Everything is a GET against that one endpoint with different query parameters — no auth header, no API key.

curl "https://clinicaltrials.gov/api/v2/studies?query.cond=diabetes&pageSize=5"

Query parameters

Param	Meaning	Example
`query.cond`	Condition / disease (Essie expression syntax).	`query.cond=lung+cancer`
`query.intr`	Intervention / drug / treatment.	`query.intr=semaglutide`
`query.spons`	Lead sponsor or collaborator name.	`query.spons=Pfizer`
`query.term`	Free-text search across fields (same expression syntax).	`query.term=obesity+AND+phase2`
`filter.overallStatus`	Comma-separated status filter.	`filter.overallStatus=RECRUITING`
`pageSize`	Studies per page — default 10, max 1000. Always set it explicitly.	`pageSize=100`
`pageToken`	Cursor for the next page, taken from `nextPageToken` in the previous response — not a numeric offset.	`pageToken=abc123`
`countTotal`	Set `true` on the first request to get a `totalCount` in the response.	`countTotal=true`
`fields`	Comma-separated field list, to shrink the payload when you don't need everything.	`fields=NCTId,BriefTitle,OverallStatus`

Examples

# Recruiting trials for a specific drug, with a total count
curl "https://clinicaltrials.gov/api/v2/studies?query.intr=semaglutide&filter.overallStatus=RECRUITING&pageSize=20&countTotal=true"

# Trials sponsored by a specific company
curl "https://clinicaltrials.gov/api/v2/studies?query.spons=Pfizer&pageSize=50"

# Free-text search, narrower payload via `fields`
curl "https://clinicaltrials.gov/api/v2/studies?query.term=obesity+AND+phase2&fields=NCTId,BriefTitle,OverallStatus,LeadSponsorName"

A response looks like this (field names abbreviated for readability — the real payload nests everything under protocolSection):

{
  "studies": [
    {
      "protocolSection": {
        "identificationModule": { "nctId": "NCT07091500", "briefTitle": "GLP-1 Receptor Agonist for Obesity" },
        "statusModule": { "overallStatus": "RECRUITING" },
        "sponsorCollaboratorsModule": { "leadSponsor": { "name": "Example University" } }
      }
    }
  ],
  "nextPageToken": "eyJ2IjoxfQ",
  "totalCount": 1234
}

(The 1234 above is a placeholder — run the countTotal=true call yourself to get the live figure for your query; it changes as new trials are registered.)

Page through everything

Pagination is cursor-based, not offset-based — grab nextPageToken from each response and pass it back as pageToken until the field is absent:

curl "https://clinicaltrials.gov/api/v2/studies?query.cond=diabetes&pageSize=1000&pageToken=eyJ2IjoxfQ"

What's in a study record

Each study nests into modules — the ones people actually query for:

Identity — nctId, briefTitle, officialTitle
Status & design — overallStatus, phases, studyType, enrollmentInfo.count
Dates — startDateStruct, completionDateStruct, lastUpdatePostDateStruct
Sponsors — leadSponsor.name, collaborators[].name
Clinical — conditions[], interventions[] (typed, e.g. DRUG: Semaglutide), briefSummary
Eligibility — sex, minimumAge, maximumAge, healthyVolunteers
Geography — contactsLocationsModule.locations[] (country, facility)

The only two rules

Be reasonable with volume — there's no published hard rate limit for anonymous use, but batch and cache rather than hammering the endpoint.
Use pageToken, not a numeric offset, to page — the API doesn't support jumping to page N.

That's the whole thing. No account, no key, no scraping the SPA frontend (which just serves bootstrap JS to a screen-scraper anyway).

If you'd rather skip the module-nesting, the pagination loop and flattening the response yourself, the ClinicalTrials.gov Scraper on Apify wraps exactly these endpoints — condition/intervention/sponsor/status filters in, one flat row per study out.

📌 Full endpoint cheatsheet (copy-paste reference): github.com/noble-ronin/clinicaltrials-api

Earthquake Data Has a Free JSON API — Every Quake on Earth, No Key Required

Noble Ronin — Mon, 27 Jul 2026 06:35:21 +0000

If you've ever needed earthquake data — for a mapping app, a risk model, a news feed, or just a hobby dashboard — you don't need to scrape earthquake.usgs.gov's web pages, and you don't need a paid data vendor. The USGS runs the FDSN Event Web Service, a free, keyless JSON API over its entire global earthquake catalogue, updated continuously.

No sign-up. No API key. No token. It's a public US government service and it's meant to be hit directly.

The base

https://earthquake.usgs.gov/fdsnws/event/1/query

Ask for GeoJSON and you get a standard FeatureCollection — one Feature per earthquake, each with a geometry.coordinates ([longitude, latitude, depthKm]) and a properties object carrying everything else:

curl "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&starttime=2026-07-01&minmagnitude=4.5&limit=5"

Each feature's properties block includes mag, magType, place, time / updated (epoch ms), tsunami (0/1 flag), alert (PAGER level: green/yellow/orange/red), sig (significance score), felt (number of "did you feel it?" reports), cdi/mmi (intensity), status (automatic/reviewed), type (earthquake, quarry blast, …), plus a detail URL for the full per-event record.

Filtering

Param	Meaning	Example
`starttime` / `endtime`	Time window, ISO or `YYYY-MM-DD`	`starttime=2026-07-01&endtime=2026-07-27`
`minmagnitude` / `maxmagnitude`	Magnitude range	`minmagnitude=5.0`
`minlatitude`/`maxlatitude`/`minlongitude`/`maxlongitude`	Bounding-box search	`minlatitude=32&maxlatitude=42&minlongitude=-125&maxlongitude=-114`
`latitude`/`longitude`/`maxradiuskm`	Circle search around a point	`latitude=35.4&longitude=139.7&maxradiuskm=200`
`mindepth` / `maxdepth`	Depth range, km	`maxdepth=70`
`alertlevel`	PAGER alert filter	`alertlevel=orange`
`orderby`	`time`, `time-asc`, `magnitude`, `magnitude-asc`	`orderby=magnitude`
`format`	`geojson` (recommended), `csv`, `xml`, `text`	`format=geojson`

Examples

# Every M4.5+ quake in the last window, newest first
curl "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&minmagnitude=4.5&orderby=time"

# California bounding box, this month
curl "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&starttime=2026-07-01&minlatitude=32&maxlatitude=42&minlongitude=-125&maxlongitude=-114"

# Within 200km of Tokyo, magnitude 5+
curl "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&latitude=35.4&longitude=139.7&maxradiuskm=200&minmagnitude=5"

# Only quakes that triggered a PAGER alert (orange/red = significant humanitarian impact)
curl "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&alertlevel=orange"

There's also a rolling set of pre-built summary feeds if you just want "what's happening right now" without building a query — https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/{significant,4.5,2.5,1.0,all}_{hour,day,week,month}.geojson — e.g. .../summary/4.5_day.geojson for every M4.5+ quake in the last 24 hours. Same GeoJSON shape as the query endpoint, refreshed every few minutes.

Notes & gotchas

Keyless, no rate-limit registration — just be reasonable with request volume; it's a shared public service.
format=geojson is the easiest to work with; format=text gives a pipe-delimited feed if you want something grep-friendly.
status starts as automatic right after an event and flips to reviewed once a seismologist confirms it — for anything safety-critical, filter on status=reviewed or expect revisions.
Depth and magnitude type (magType) vary by network — mww, ml, mb etc. aren't directly comparable across all ranges; don't average them naively.
Circle search (latitude/longitude/maxradiuskm) and bounding-box search are mutually exclusive — pick one.

Full endpoint reference + copy-paste table: noble-ronin/usgs-earthquake-api on GitHub.

Want the filtered rows without building the query string yourself? The Earthquake Data Scraper on Apify wraps this same endpoint — set magnitude/time/bbox in a form, get clean rows out, schedule it as a live alert feed.

I Pulled Live Jobs Straight From OpenAI, Stripe, Airbnb and Bosch — Each Took One API Call

Noble Ronin — Sat, 25 Jul 2026 07:26:37 +0000

I wanted live, structured job listings from a handful of big companies — no LinkedIn middleman, no Indeed anti-bot wall, no headless browser. So I just asked each company's own applicant tracking system (ATS) directly.

Here's what one keyless call returned, live today:

OpenAI — 755 open roles (Ashby)
Bosch — 4,773 (SmartRecruiters)
Stripe — 535 (Greenhouse)
Palantir — 287 (Lever)
Airbnb — 196 (Greenhouse)
Spotify — 108 (Lever)

No sign-up. No API key. No token. No proxy. Every number above came from a plain curl against the company's public board API — the same JSON their own careers page renders from.

Why the ATS, not LinkedIn or Indeed

LinkedIn and Indeed scrapers fight aggressive anti-bot systems. They break, they rate-limit, they silently return half the results, and you spend more time babysitting proxies than using the data.

A company's ATS has no reason to fight you: it's the endpoint its own careers page calls. It's the source of truth, it's fast, and for the big four ATS platforms below it's a clean public JSON API. You just have to know the shape of the call.

The four calls

Greenhouse

The board token is the slug in boards.greenhouse.io/<token>.

curl "https://boards-api.greenhouse.io/v1/boards/stripe/jobs?content=true"

Returns every posting with title, location, department and (with content=true) the full HTML description. Stripe returned 535 live roles; Airbnb, 196.

Lever

curl "https://api.lever.co/v0/postings/palantir?mode=json"

A flat JSON array — Palantir returned 287 postings, each with categories, workplace type and apply URL. Spotify: 108.

Ashby

curl "https://api.ashbyhq.com/posting-api/job-board/openai?includeCompensation=true"

OpenAI's entire board — 755 roles — comes back in one response, compensation bands included where published.

SmartRecruiters

curl "https://api.smartrecruiters.com/v1/companies/BoschGroup/postings?limit=100"

Paginated with limit/offset. Bosch (BoschGroup) exposes 4,773 postings this way — a genuinely large, structured hiring dataset for free.

It's not just the big four

Those are the platforms with the marquee names, but the same "your ATS is already an API" trick works on more:

Workday — POST to the /wday/cxs/.../jobs CXS endpoint (pass the full board URL)
BambooHR — {company}.bamboohr.com/careers/list
Personio — {company}.jobs.personio.com/xml
Recruitee — {company}.recruitee.com/api/offers/
Breezy HR — {company}.breezy.hr/json

That's nine ATS platforms, each with a public listing endpoint. The exact URL patterns, response fields and gotchas for all nine are in this cheatsheet:

👉 noble-ronin/ats-job-apis

One honest caveat

Companies migrate. While checking this I hit api.lever.co/v0/postings/brex and got back {"ok":false,"error":"Document not found"} — Brex had moved off Lever. So in practice you want to detect which ATS a company is on before you call it, and fall through the list until one answers.

That detection-plus-fetch across all nine ATS is exactly what I wrapped into an actor, if you'd rather pass a company name and get clean rows out than wire up nine endpoints yourself:

👉 Multi-ATS Job Scraper — give it a company or a careers-board URL, it auto-detects the ATS and returns structured, real-time jobs, with a monitor mode for new postings.

But you don't need it to get started. Pick a company, guess their ATS from the careers-page URL, and run the matching curl above. The odds it just works are better than you'd think.

All counts verified live on 2026-07-25 from an EU IP with no API key. Live numbers will drift as companies open and close roles.

FDA Recalls Have a Free JSON API — Every Drug, Device and Food Recall Without Scraping

Noble Ronin — Fri, 24 Jul 2026 20:10:06 +0000

If you need FDA recall data — which drugs, devices and foods got pulled, why, by whom, and how serious it was — you do not need to scrape fda.gov, and you do not need a paid API. The FDA runs openFDA, a free, keyless JSON API over its own enforcement, adverse-event and labeling databases.

No sign-up. No API key. No token. There's a higher rate limit if you register a free key, but every endpoint below works with nothing at all.

The base

https://api.fda.gov

Recalls live under the enforcement endpoints, one per product area:

curl "https://api.fda.gov/drug/enforcement.json?limit=1"
curl "https://api.fda.gov/device/enforcement.json?limit=1"
curl "https://api.fda.gov/food/enforcement.json?limit=1"

Each response has a meta block (with results.total) and a results array. A single drug-recall record carries recalling_firm, product_description, reason_for_recall, classification (Class I / II / III — I is the most serious), status (Ongoing / Completed / Terminated), recall_initiation_date, distribution_pattern, code_info, plus an openfda block that links the product back to NDC codes and brand/generic names.

Search with the `search` parameter

openFDA uses a simple field:value query syntax. Quote multi-word values and URL-encode:

# All Class I (most serious) drug recalls
curl 'https://api.fda.gov/drug/enforcement.json?search=classification:"Class+I"&limit=5'

# Recalls that are still Ongoing
curl 'https://api.fda.gov/drug/enforcement.json?search=status:"Ongoing"'

# Ranges and booleans work too — food recalls initiated in 2026
curl 'https://api.fda.gov/food/enforcement.json?search=recall_initiation_date:[20260101+TO+20261231]'

At the time of writing there are 1,733 Class I drug recalls on record and 2,580 with an Ongoing status — all as structured JSON, no scraping.

Count instead of list

Add count=<field>.exact and openFDA returns an aggregation instead of raw rows — great for dashboards:

curl "https://api.fda.gov/drug/enforcement.json?count=classification.exact"

Right now that returns Class II = 14,381, Class I = 1,733, Class III = 1,701. One call, the whole distribution.

Page through everything

curl "https://api.fda.gov/device/enforcement.json?limit=100&skip=200"

limit (max 1000) and skip page the results. The device enforcement set alone is 39,539 records; food is 29,238.

Beyond recalls

Same base, same keyless deal, for two more datasets people usually ask about in the same breath:

# Adverse event reports (FAERS)
curl "https://api.fda.gov/drug/event.json?limit=1"

# Structured drug product labeling
curl "https://api.fda.gov/drug/label.json?limit=1"

The only two rules

Be reasonable with volume — anonymous calls are rate-limited (a registered free key just raises the ceiling).
Page with limit + skip, and remember openFDA data is a snapshot the FDA refreshes periodically, not a live wire.

That's the whole thing.

If you'd rather skip the paging, the search encoding and the field-mapping, the FDA Recalls Scraper on Apify wraps exactly these endpoints — drug/device/food, class and status filters in, structured rows out.

📌 Full endpoint cheatsheet (copy-paste reference): github.com/noble-ronin/fda-recalls-api

EU Public Tenders Have a Free JSON API — Every Notice, Buyer and Deadline Without Scraping

Noble Ronin — Mon, 20 Jul 2026 15:24:18 +0000

If you need EU public procurement data — who's buying what, from which government body, for how much, closing when — you do not need a scraper, and you do not need to pay one of the half-dozen "TED scraper" tools on the market. The EU's own TED (Tenders Electronic Daily) journal exposes all of it as clean JSON through an official, keyless v3 search API.

No sign-up. No API key. No token. Just a POST request.

The endpoint

POST https://api.ted.europa.eu/v3/notices/search

Anonymous access — search and retrieval require no authentication at all (only submitting notices does).

Pull the newest notices

curl -X POST 'https://api.ted.europa.eu/v3/notices/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "FT~\"cloud computing\" SORT BY publication-date DESC",
    "fields": ["publication-number", "notice-title", "buyer-name", "buyer-country", "deadline"],
    "limit": 10,
    "scope": "ACTIVE",
    "paginationMode": "ITERATION"
  }'

query uses TED's expert-search syntax: FT~"..." for full-text, field filters like buyer-country=DEU or PD>=20260101 (publication date), combined with AND/OR, and SORT BY publication-date DESC to get live opportunities instead of the 2016 backlog. fields is an explicit allowlist — ask for exactly the eForms fields you want back (notice-title is always included even if you forget it).

What comes back

Each notice in the notices array is keyed by the same eForms field names you requested — notice-title, buyer-name, classification-cpv (procurement category codes), total-value / total-value-cur, deadline, links. Multilingual fields like the title arrive as an object keyed by language ({"eng": [...], "fra": [...]}) rather than a plain string — grab eng when present, fall back to whatever language is there.

Filter by country, value, category

# German buyers, AI-related, published this year
curl -X POST 'https://api.ted.europa.eu/v3/notices/search' \
  -H 'Content-Type: application/json' \
  -d '{"query": "FT~\"artificial intelligence\" AND buyer-country=DEU AND PD>=20260101 SORT BY publication-date DESC", "fields": ["publication-number","notice-title","buyer-name","total-value","deadline"], "limit": 50, "scope": "ACTIVE"}'

Page through results

Set paginationMode: "ITERATION" and bump page (or follow the pagination token TED returns) while limit stays at or under 100 per call. scope: "ACTIVE" returns currently-open notices; use "ALL" to search the full historical archive (480,000+ notices back to the mid-2010s).

The one gotcha

Field names are the eForms names (notice-title, classification-cpv, buyer-country) — not the old two-letter TED codes from the legacy API. If you copy a query from a pre-2023 blog post, expect it to 404 or return nothing; the schema changed with the eForms rollout.

That's the whole thing: one POST endpoint, an expert-search query string, and a field allowlist — no key, no proxy, no anti-bot to fight.

If you'd rather skip the pagination and the multilingual-field unwrapping, the EU Tenders Scraper on Apify wraps exactly this endpoint — keyword or expert query in, flat rows out (buyer, country, CPV, value, deadline, direct link).

📌 Full field reference + copy-paste query cheatsheet: github.com/noble-ronin/ted-tenders-api

US Regulations Have a Free JSON API — Every Rule, Notice and Executive Order Without Scraping

Noble Ronin — Thu, 16 Jul 2026 11:47:52 +0000

If you need US federal regulations as data — final rules, proposed rules, public notices, executive orders — you do not need to scrape, and you do not need a paid API. The Federal Register (the daily journal of the US government) publishes everything as clean JSON through a free, keyless API.

No sign-up. No API key. No token. The only limit is a polite rate cap.

The base

https://www.federalregister.gov/api/v1

Pull the latest documents

curl "https://www.federalregister.gov/api/v1/documents.json?per_page=5&order=newest"

You get back count, total_pages, and a results array. Each result includes document_number, type (Rule / Proposed Rule / Notice / Presidential Document), title, abstract, publication_date, agencies, and direct html_url and pdf_url links to the official text.

Search by term, agency, date or type

The API takes conditions[...] filters:

# Everything mentioning "artificial intelligence"
curl "https://www.federalregister.gov/api/v1/documents.json?conditions%5Bterm%5D=artificial+intelligence"

# Final rules from the EPA, published this year
curl "https://www.federalregister.gov/api/v1/documents.json?conditions%5Btype%5D%5B%5D=RULE&conditions%5Bagencies%5D%5B%5D=environmental-protection-agency&conditions%5Bpublication_date%5D%5Bgte%5D=2026-01-01"

At the time of writing, the plain artificial intelligence term search returns 1,504 documents — all as structured JSON.

Fetch one document in full

curl "https://www.federalregister.gov/api/v1/documents/2026-14454.json"

That returns the full record for a single document number, including the abstract, the list of affected CFR parts, docket IDs, and links to the raw text (body_html_url, full_text_xml_url).

List every agency

curl "https://www.federalregister.gov/api/v1/agencies.json"

472 agencies, each with its slug (use it in the conditions[agencies][] filter above).

The only two rules

Be reasonable with request volume — it's a public-good API, not a firehose to hammer.
Page with per_page (max 1000) and page, or use order=newest for a rolling feed.

That's the whole thing. For consolidated regulations already in force (as opposed to the daily journal of changes), pair this with the sibling eCFR API — same idea, also keyless.

If you'd rather skip the paging, the field-mapping and the retry logic, the Federal Register Scraper on Apify wraps exactly these endpoints — term/agency/type/date filters in, structured rows out.

📌 Full endpoint cheatsheet (copy-paste reference): github.com/noble-ronin/federal-register-api

SEC Filings Have a Free JSON API — Pull Any Company's 10-Ks, 8-Ks and Insider Trades Without a Key

Noble Ronin — Thu, 16 Jul 2026 10:36:30 +0000

Everyone assumes financial data means a paid API — Bloomberg, a scraper you have to
babysit, or some $200/month "filings API" wrapper. For raw SEC filings, none of that
is necessary. The SEC runs its own free, public JSON API, and it's been stable and
keyless for years.

The three endpoints that cover almost everything

1. Ticker → CIK lookup

SEC filings are indexed by CIK (Central Index Key), not ticker. One file maps every
public company:

curl -s -H "User-Agent: Your Name your@email.com" \
  https://www.sec.gov/files/company_tickers.json | head -c 200

Returns a JSON object keyed by row number, each with cik_str, ticker, title.
Apple is CIK 320193 — zero-pad it to 10 digits for the endpoints below.

2. A company's full filing history

curl -s -H "User-Agent: Your Name your@email.com" \
  https://data.sec.gov/submissions/CIK0000320193.json | head -c 400

That single call returns the company's name, SIC industry code, exchange/ticker, and
a filings.recent array with every filing — form type (10-K, 10-Q, 8-K, 4
for insider trades, 13F-HR for institutional holdings, DEF 14A, S-1, …),
filingDate, reportDate, and accessionNumber (which you turn into a direct
document URL). No pagination dance for recent history — at least a year, or the
1,000 most recent filings, in one response.

3. Full-text search across every filing, ever

Want every 8-K that mentions a specific phrase, across every company? That's a
separate index:

curl -s -H "User-Agent: Your Name your@email.com" \
  "https://efts.sec.gov/LATEST/search-index?q=%22material+weakness%22&forms=10-K&startdt=2026-01-01&enddt=2026-06-30"

Results come back Elasticsearch-style under hits.hits, each with a display name,
CIK, form type, filing date, and accession number — everything you need to build the
document URL without a second request.

The only two rules

Send a real User-Agent. Not a browser string — an actual identifier: your name and an email address. This is the SEC's entire "access control" — no key, no OAuth, no sign-up form. Skip it and you'll get blocked.
Stay under 10 requests/second. That's the documented fair-access ceiling across data.sec.gov and efts.sec.gov combined. Fine for almost any real workload; just don't fire filings in a tight loop with zero delay.

That's the whole barrier to entry. No key rotation, no free-tier quota that resets
monthly, no CAPTCHA wall — because there isn't a wall.

Where this gets tedious at scale

The endpoints above are clean, but real usage runs into the boring parts fast: CIK
padding, mapping every form-type filter you actually want (10-K and 10-K/A,
say), pagination past the first page of full-text search results, retry/backoff to
respect the rate limit, and turning accession numbers into working document links.
None of that is hard — it's just the kind of glue code you don't want to write twice.

That's basically what SEC EDGAR Filings Scraper & Full-Text
Search wraps: same free
official API underneath, but you pass tickers or CIKs plus optional form filters and
a date range, and get back one flat row per filing — company, CIK, form, dates,
accession number, and a direct filing URL, ready to drop into a spreadsheet or a
pipeline. Same data as the curl calls above, just without the glue code.

Want the endpoints without the narrative? Full reference table + curl examples +
gotchas: SEC EDGAR JSON API — a
cheatsheet.

If you liked this one, I also wrote up how job boards expose a public JSON API
underneath the "no API" LinkedIn/Indeed
experience — same pattern, different domain: the data's public, you just have to know where to look.

Skip LinkedIn/Indeed: most companies' job boards have a public JSON API

Noble Ronin — Mon, 13 Jul 2026 15:33:36 +0000

If you've ever tried to pull job listings by scraping LinkedIn or Indeed, you know the pain: anti-bot systems, CAPTCHAs, rotating proxies, and scripts that silently break every few weeks.

Here's the thing — you usually don't need any of that.

Companies don't post jobs on LinkedIn first. They post them in their ATS (Applicant Tracking System) — Greenhouse, Lever, Ashby, Workday, etc. — and most ATS platforms expose the company's board as a public JSON endpoint. No key, no login, no browser. It's the company's own source of truth, so it's cleaner and fresher than any aggregator.

The endpoints

A few that work with a plain GET ({company} = the company's slug):

Greenhouse — https://boards-api.greenhouse.io/v1/boards/{company}/jobs?content=true
Lever — https://api.lever.co/v0/postings/{company}?mode=json
Recruitee — https://{company}.recruitee.com/api/offers/
Breezy HR — https://{company}.breezy.hr/json

SmartRecruiters, Ashby, BambooHR and Personio have their own equivalents. Workday is the one annoying exception — it's a POST and needs the full board URL (tenant + datacenter + site), so you can't guess it from a bare company name.

Example: pulling Stripe's open roles (Python)

Stripe uses Greenhouse:

import requests

company = "stripe"
url = f"https://boards-api.greenhouse.io/v1/boards/{company}/jobs?content=true"
jobs = requests.get(url).json()["jobs"]

for j in jobs[:5]:
    print(j["title"], "—", j["location"]["name"])

That's it. No Selenium, no proxy, no CAPTCHA solver. Runs in ~200ms and won't break next Tuesday because Cloudflare changed something.

Auto-detecting the ATS

If you don't know which ATS a company uses, just try them in order and take the first one that returns jobs. A bare 404 means "not this ATS, try the next." Greenhouse → Lever → Ashby → SmartRecruiters → Recruitee → Breezy covers a huge chunk of tech companies.

Gotchas

Rate limits are lenient but real — be polite, set a User-Agent.
Descriptions: Greenhouse/Lever include full HTML descriptions in the list; Breezy's list endpoint doesn't (you'd fetch each posting for that).
Workday: POST-only, needs the full board URL — worth special-casing.

If you don't want to build/maintain 9 of these

I got tired of keeping a fetcher per ATS in sync, so I bundled 9 of them (Greenhouse, Lever, Ashby, SmartRecruiters, Workday, BambooHR, Personio, Recruitee, Breezy) into one thing that auto-detects the ATS from a bare company name or board URL and returns normalized jobs: https://apify.com/ponderable_hydrometer/multi-ats-jobs

But honestly, the endpoints above are the real value — build your own if you'd rather.

Which ATS should I add next? Considering Workable, Teamtailor and JazzHR.

DEV Community: Noble Ronin

Clinical Trials Data Has a Free JSON API — Every Study on ClinicalTrials.gov, No Key Required

The base

Query parameters

Examples

Page through everything

What's in a study record

The only two rules

Earthquake Data Has a Free JSON API — Every Quake on Earth, No Key Required

The base

Filtering

Examples

Notes & gotchas

Related

I Pulled Live Jobs Straight From OpenAI, Stripe, Airbnb and Bosch — Each Took One API Call

Why the ATS, not LinkedIn or Indeed

The four calls

Greenhouse

Lever

Ashby

SmartRecruiters

It's not just the big four

One honest caveat

FDA Recalls Have a Free JSON API — Every Drug, Device and Food Recall Without Scraping

The base

Search with the search parameter

Count instead of list

Page through everything

Beyond recalls

The only two rules

EU Public Tenders Have a Free JSON API — Every Notice, Buyer and Deadline Without Scraping

The endpoint

Pull the newest notices

What comes back

Filter by country, value, category

Page through results

The one gotcha

US Regulations Have a Free JSON API — Every Rule, Notice and Executive Order Without Scraping

The base

Pull the latest documents

Search by term, agency, date or type

Fetch one document in full

List every agency

The only two rules

SEC Filings Have a Free JSON API — Pull Any Company's 10-Ks, 8-Ks and Insider Trades Without a Key

The three endpoints that cover almost everything

1. Ticker → CIK lookup

2. A company's full filing history

3. Full-text search across every filing, ever

The only two rules

Where this gets tedious at scale

Skip LinkedIn/Indeed: most companies' job boards have a public JSON API

The endpoints

Example: pulling Stripe's open roles (Python)

Auto-detecting the ATS

Gotchas

If you don't want to build/maintain 9 of these

Search with the `search` parameter