Ashby has become a common applicant tracking system at startups and AI companies. Its hosted job boards live at jobs.ashbyhq.com/{board}, and Ashby documents a public posting API that returns the same jobs as JSON. For job data it also has something the older systems often lack, structured salary ranges, when the company chooses to publish them.

The endpoint

GET https://api.ashbyhq.com/posting-api/job-board/{board}?includeCompensation=true

{board} is the part after jobs.ashbyhq.com/. For jobs.ashbyhq.com/openai it is openai. No key is needed to read published jobs. An unknown board returns HTTP 404.

import requests

def ashby_jobs(board):
    url = f"https://api.ashbyhq.com/posting-api/job-board/{board}"
    resp = requests.get(url, params={"includeCompensation": "true"}, timeout=30)
    if resp.status_code == 404:
        return None
    resp.raise_for_status()
    return resp.json()["jobs"]

jobs = ashby_jobs("ashby")
print(len(jobs), "jobs")
for j in jobs[:5]:
    print(j["title"], "|", j["department"], "|", j["location"], "|", j["workplaceType"], "|", j["publishedAt"][:10])

The whole board comes back in one response. OpenAI’s board had 830 jobs when I checked, with no paging.

Fields worth knowing

• title, department, team, employmentType
• location plus secondaryLocations for jobs open in several places
• isRemote and workplaceType
• publishedAt, an ISO timestamp
• jobUrl and applyUrl
• descriptionPlain and descriptionHtml
• isListed, which is false for unlisted jobs that are reachable only by link
• compensation, only when you pass includeCompensation=true

Reading the salary

compensation.summaryComponents is a list of parts: salary, bonus, equity and so on. Each has compensationType, interval, currencyCode, minValue and maxValue. The salary is the part whose type is Salary:

def salary_range(job):
    comp = job.get("compensation") or {}
    for part in comp.get("summaryComponents") or []:
        if part.get("compensationType") == "Salary" and part.get("minValue") is not None:
            return part["minValue"], part["maxValue"], part["currencyCode"], part["interval"]
    return None

for j in jobs:
    s = salary_range(j)
    if s:
        print(j["title"], s)

On Ashby’s own board, an engineering manager role in the EU returned (110000, 185000, 'EUR', '1 YEAR'). There is also compensationTierSummary, a display string such as “€110K - €185K • Offers Equity”, which is handy for a UI but not for math.

A useful side effect: publishedAt shows how long a job has been open. The same board had a job first published in March 2024 and still listed in September 2026. Old open jobs are normal on career pages, and job aggregators often drop them.

Where this stops being enough

For one board this is ten lines of code. The trouble starts with a list:

• Board names. A list of company websites does not tell you the Ashby board name, or whether the company uses Ashby at all.
• Mixed systems. Few lists are all Ashby. Greenhouse and Lever are common in the same segment, and European companies often use Personio, Teamtailor or Recruitee.
• Other salary formats. Ashby gives structured pay. Greenhouse usually does not in its list endpoint, and Lever only sometimes. Comparing pay across companies needs one format.
• What changed. New, closed and reposted jobs need stored history.

A hosted option for many Ashby boards

Ashby Jobs API is an Apify Actor I built for this. You give it Ashby board links, company websites or plain names, it reads the same public posting API for each one, and it returns every job in a fixed format. Ashby salaries arrive as salaryMin, salaryMax, salaryCurrency and salaryPeriod, with salaryRanges holding one range per pay tier, plus salaryAnnualMin and salaryAnnualMax converted to a yearly figure.

pip install "apify-client>=3.2,<4"
export APIFY_TOKEN=<YOUR_APIFY_TOKEN>

import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("conserving_celerytop/ashby-jobs-api").call(
    run_input={
        "companies": [
            "https://jobs.ashbyhq.com/openai",
            "https://jobs.ashbyhq.com/ashby",
        ],
        "hasSalary": True,
        "minAnnualSalary": 150000,
        "minAnnualSalaryCurrency": "USD",
    },
    max_total_charge_usd=Decimal("0.50"),
)

for r in client.dataset(run.default_dataset_id).iterate_items():
    if r["rowType"] == "job":
        print(r["companySlug"], "|", r["title"], "|", r["salaryAnnualMin"], "-", r["salaryAnnualMax"], r["salaryCurrency"])

hasSalary keeps only jobs with published pay, from the board field or written in the job text. minAnnualSalary compares the yearly figure in the currency you name. There are no exchange rates, so jobs paid in euros or pounds are left out of a USD filter, and the warning field counts them. Set the currency to match the market you are looking at.

To watch a set of Ashby companies, add "onlyNewJobs": true and "monitorName": "ashby-watch", save the input as a task, and schedule it. Later runs return only new and closed jobs.

If your list mixes Ashby with Greenhouse, Lever or Workday, ATS Jobs API from the same author reads 22 systems with the same fields, at $0.045 per company.

Pricing

Free plan prices on the Apify Store on September 27, 2026. Check the Store page before relying on them.

• $0.10 per company, including up to 1,000 of its open jobs ($0.09 on Scale, $0.07 on Business). Each further 1,000 jobs of that company is $0.045.
• A later check with onlyNewJobs is $0.002 per 1,000 open jobs on the board.
• Descriptions cost nothing extra.
• A name that turns out not to be on Ashby is still charged, because the board was looked up. Links to other job boards, websites that cannot be read, duplicates and invalid entries are free.
• Paid Apify plans pay less per company. The free plan gives $5 of credit a month, which covers about 50 companies.

The example above, two companies, costs $0.20.

When not to use it

• One or two Ashby boards: the public endpoint is free and simple.
• A keyword search across every Ashby company: this reads the companies you list. It is not a search engine over all boards.
• Your own Ashby hiring data (candidates, interviews): that is Ashby’s authenticated API, with a key from your Ashby admin.

FAQ

Does Ashby’s job posting API need a key? No, not for published jobs.

Why is compensation missing? Either you did not pass includeCompensation=true, or the company does not show pay on that job.

Are unlisted jobs included? The API can return jobs with isListed set to false. Filter on it if you only want jobs shown on the public board. The Actor leaves unlisted jobs out.

Ashby is a trademark of its owner. This article and the Actors are not affiliated with or endorsed by Ashby. The Actors read only jobs published on public boards, with no login.

A company that opens three sales roles this month is about to change how it sells. One that posts its first data engineer is about to buy data tools. Job postings are one of the few buying signals a company publishes on purpose, with dates, in public.

Most signal tools sell that data inside a larger platform. If you already have an account list, you can build the core of it yourself: read each account’s careers page, count what they are hiring for, and flag the changes. This guide does that in Python.

Which hiring signals matter

Pick signals that map to what you sell. Some that hold up in practice:

• Hiring in your buyer’s team. Selling to RevOps? Watch for sales and RevOps roles. Selling dev tools? Watch engineering.
• A first hire in a function. “Founding data engineer” or “first marketing hire” means someone is about to pick tools with no incumbent.
• New leadership. An open VP or director role often comes before a budget and a vendor review.
• Speed. Many roles posted in the last 30 days, compared with the total open.
• Expansion. Jobs in a country where the account had none before.
• Tools in the job text. A post that asks for Salesforce, Snowflake or HubSpot experience tells you what they already run.

None of these proves intent. They tell you where to look first, and they give the first line of an email something true to say.

Step 1: one summary row per account

ATS Jobs API reads the public careers pages of the companies you give it: Greenhouse, Lever, Ashby, Workday and 18 other job board systems. With outputMode set to companies, it returns one summary row per account instead of one row per job.

pip install "apify-client>=3.2,<4"
export APIFY_TOKEN=<YOUR_APIFY_TOKEN>

import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

with open("accounts.txt") as f:          # one website or domain per line
    accounts = [line.strip() for line in f if line.strip()]

run = client.actor("conserving_celerytop/live-career-page-jobs-api").call(
    run_input={
        "companies": accounts[:500],
        "outputMode": "companies",
        "includeDescription": True,     # adds topTools and first hires found in the job text
    },
    max_total_charge_usd=Decimal("25.00"),  # a hard cap, not the price; see "What it costs"
)

rows = [r for r in client.dataset(run.default_dataset_id).iterate_items() if r["rowType"] == "company"]

Each summary row includes:

Accounts it cannot resolve come back as rows with rowType set to status and a reason in companyStatus, such as no_job_board_found. Websites work when the site links to its job board; a board link always works best.

Step 2: score the accounts

Here is a simple score for a team that sells to sales leaders. Change the weights to fit your product.

def score(r, function="sales"):
    recent = (r.get("functionCountsLast30Days") or {}).get(function, 0)
    total = (r.get("functionCounts") or {}).get(function, 0)
    leaders = [x for x in (r.get("leadershipRoles") or []) if x.get("jobFunction") == function]
    firsts = [x for x in (r.get("firstHireRoles") or []) if x.get("jobFunction") == function]
    return recent * 3 + total + len(leaders) * 10 + len(firsts) * 15

ranked = sorted(rows, key=score, reverse=True)
for r in ranked[:25]:
    leads = ", ".join(x["title"] for x in (r.get("leadershipRoles") or [])[:2])
    name = r.get("companySlug") or r["company"]
    print(f'{name:<20} score={score(r):>3}  sales_open={(r.get("functionCounts") or {}).get("sales", 0):>3}  {leads}')

Push the top 25 to your CRM with the job titles as context. “Saw you’re hiring a VP Sales and four AEs in Austin” beats a generic opener, and it is true.

Step 3: a weekly list of what changed

A snapshot is useful once. The value is in change. Add three fields and schedule it:

run_input = {
    "companies": accounts[:500],
    "outputMode": "companies",
    "onlyNewJobs": True,
    "monitorName": "accounts-weekly",
}

The first run records every open job. Each later run adds newJobs, closedJobs, newFunctions (functions with open roles now that had none last time, for example ["sales"]) and newCountries. Save the input as a task in Apify Console, add a weekly schedule, and send the result to Slack, Google Sheets or a webhook. An account whose newFunctions contains your buyer’s team is worth a look that week.

What it costs

On September 27, 2026 the Store price was $0.045 per account, with up to 1,000 jobs included, and $0.0428, $0.0405 or $0.036 on paid Apify plans. Prices can change, so check the Store page before a large run. How it adds up:

• The first run costs one company lookup per account. In companies mode that is the whole price per account, however many jobs it has. So the first run for 500 accounts costs $22.50 on the free plan.
• Job descriptions, needed for topTools and first hires found in the text, are free on most systems. Workday, Eightfold and a few smaller systems, such as JazzHR and Paylocity, cost $0.01 per started block of 200 jobs described.
• Each weekly check after the first costs $0.002 per 1,000 open jobs on each board (checked September 27, 2026). Most accounts have fewer than 1,000 open jobs, so 500 accounts cost about $1 a week.
• max_total_charge_usd in the code is a hard cap. The run stops before it spends more.

Apify’s free plan includes $5 of credit a month.

Limits you should know

• Function labels are read from titles. Some jobs land in the wrong function, so read the titles before you act on a count. salesShare and engineeringShare use simpler keyword rules.
• It reads the companies you list. It will not find new accounts that are hiring. Bring a list from your CRM or a data provider.
• Not every company has a careers page system. Small companies that post only on LinkedIn come back as not found.
• Old postings are included. Some companies keep evergreen roles open all year. jobsPostedLast30Days separates new hiring from old listings.

FAQ

Is hiring really a buying signal? It is a timing signal. It shows where budget and headcount are going, which is often where new tools are bought. Use it to prioritize, not as proof.

Can I get the hiring manager’s name? No. The Actor reads job postings only and returns no personal data.

How is this different from a signals platform? You get the raw counts and job titles for your own list, at a per-account price, and you decide the scoring. Platforms bundle more sources and contact data.

This article and the Actor are not affiliated with or endorsed by Greenhouse, Lever, Ashby, Workday or any other job board. The Actor reads only jobs published on public careers pages, with no login.

“Lever API” means two different things, and search results mix them up. One is the Lever API for customers, which reads candidates, opportunities and interviews and needs an API key from the company’s Lever account. The other is the Postings API, which serves the jobs a company publishes on its Lever job site. The Postings API is public for reading, and it is the one you want for job data.

The endpoint

Every Lever job site at jobs.lever.co/{site} has a matching JSON endpoint:

GET https://api.lever.co/v0/postings/{site}?mode=json

Boards hosted in Lever’s EU region live at jobs.eu.lever.co/{site}, and their API host is api.eu.lever.co. If a site returns {"ok": false, "error": "Document not found"} on one host, try the other before you give up on it.

import requests
from datetime import datetime, timezone

def lever_postings(site, eu=False):
    host = "api.eu.lever.co" if eu else "api.lever.co"
    resp = requests.get(f"https://{host}/v0/postings/{site}", params={"mode": "json"}, timeout=30)
    data = resp.json()
    if isinstance(data, dict) and data.get("ok") is False:
        return None  # no such site on this host
    return data

jobs = lever_postings("palantir")
print(len(jobs), "open postings")
for p in jobs[:5]:
    created = datetime.fromtimestamp(p["createdAt"] / 1000, tz=timezone.utc).date()
    cats = p["categories"]
    print(p["text"], "|", cats.get("team"), "|", cats.get("location"), "|", p.get("workplaceType"), "|", created)

On the day I ran it, Palantir’s site returned 321 postings in one response.

What each posting contains

The fields you will use most:

salaryRange is optional, and in my checks many companies leave it empty, including Palantir and Spotify on that day. If pay matters to you, also search descriptionPlain and additionalPlain, where some companies write the range as text.

Paging, filters and politeness

The endpoint accepts skip and limit, plus filters such as team, location, commitment and department (case sensitive when you pass several values). Without limit it returns the full list, which is usually what you want. Lever’s docs describe a rate limit for application POSTs, not for reading postings, but the same manners apply: one request per site per run, cached, with a clear User-Agent.

Where the one-script approach runs out

The script above is fine for a few companies. At 50 or 500 companies you run into four jobs you did not plan for:

1. Finding the site name. Your list is company names and websites, not Lever site slugs. Some companies are on the EU host, and many are not on Lever at all.
2. Mixed systems. Sales and recruiting lists mix Lever with Greenhouse, Ashby, Workday and smaller European systems.
3. Change tracking. Lever shows what is open. New and closed jobs since last week need stored state and a diff.
4. One schema. Location, seniority, function and salary need normalizing before a spreadsheet or CRM can use them.

A hosted option

I built Lever Jobs API on Apify for that case. It reads the same public Postings API, handles both regions, and returns one row per job in a fixed format. You pass Lever links, websites or company names.

pip install "apify-client>=3.2,<4"
export APIFY_TOKEN=<YOUR_APIFY_TOKEN>

import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("conserving_celerytop/lever-jobs-api").call(
    run_input={
        "companies": ["https://jobs.lever.co/palantir", "https://jobs.lever.co/spotify"],
        "jobFunctions": ["engineering", "data"],
        "postedSince": "14 days",
    },
    max_total_charge_usd=Decimal("0.50"),
)

rows = list(client.dataset(run.default_dataset_id).iterate_items())
jobs = [r for r in rows if r["rowType"] == "job"]
print(len(jobs), "matching jobs")
for r in jobs[:10]:
    print(r["companySlug"], "|", r["title"], "|", r["seniority"], "|", r["location"], "|", r["url"])

createdAt becomes an ISO date in postedAt. categories.location becomes location plus countryCode. The title is read for seniority (intern to C-level) and jobFunction (engineering, sales, data and so on), so you can filter the rows before they reach your spreadsheet. A company that cannot be found gets a status row that says why, and that row is not dropped.

For a watchlist, add "onlyNewJobs": true and a "monitorName". After the first run, each run returns only new and closed postings. Save it as an Apify task and schedule it daily or weekly.

Pricing

Free plan prices on the Apify Store on September 27, 2026. Check the Store page before you rely on them.

• Lever Jobs API: $0.10 per company with up to 1,000 open jobs ($0.09 on Scale, $0.07 on Business), then $0.045 per further 1,000. A later onlyNewJobs check is $0.002 per 1,000 open jobs. 100 Lever companies cost $10 for a full pull and about $0.20 per daily check after that. The example above, two companies, costs $0.20.
• ATS Jobs API reads Lever and 21 other systems with the same fields. It costs $0.045 per company with up to 1,000 jobs, less than the Lever-only version, so it is worth a look even for an all-Lever list.

Paid Apify plans pay less per company. The free plan includes $5 of credit a month.

When you should not use it

• A few Lever sites and no need for history: call the endpoint directly. It is free.
• You need every Lever job on the internet, searched by keyword: neither the endpoint nor the Actor does that. You supply the companies.
• You need candidates or pipeline data from your own Lever account: that is the authenticated Lever API, with a key from your admin.

FAQ

Does the Lever Postings API need an API key? Not for reading published postings. A key is needed to post applications and for the main Lever API.

Why do I get “Document not found”? The site name is wrong, the board is on the EU host, or the company does not use Lever.

How do I get the posting date? createdAt is milliseconds since 1970. Divide by 1,000 and convert to a date.

Lever is a trademark of its owner. This article and the Actors are not affiliated with or endorsed by Lever. The Actors read only published postings, with no login.

Knowing what a website runs on is useful in a lot of jobs. An agency that builds on Shopify wants the Shopify stores in its market. A payments company wants to know who already uses Stripe. A sales team wants to sort 2,000 leads by CMS before it writes a single email.

You can do this by hand with a browser extension, one site at a time. For a list, you want an API. This guide explains how detection works, gives you a small script to try it yourself, and then shows a hosted option for large lists.

How tech stack detection works

Most tools, commercial or open source, work the same way. They load a page and look for fingerprints:

• Script and stylesheet URLs. cdn.shopify.com means Shopify, js.stripe.com means Stripe, /wp-content/ means WordPress.
• HTML markers. A <meta name="generator"> tag, or attributes such as data-wf-site on Webflow sites.
• Response headers and cookies. Server, X-Powered-By and cookie names often name the platform or host.
• Versions, when a file name or tag includes one.

A widely used open fingerprint set started in the Wappalyzer project and is now maintained as webappanalyzer, with thousands of technologies and their patterns. Accuracy depends on what the page shows. A tool that is loaded later by JavaScript, for example an analytics tag inside a tag manager, only appears if you run the page in a browser.

A small script to try it yourself

This script checks a site’s robots.txt, loads the homepage once, and looks for a few fingerprints. The patterns are examples, not a full set.

import re
import requests
from urllib.robotparser import RobotFileParser

UA = "stack-check-example/0.1 (+https://example.com/contact)"
SIGNS = {
    "Shopify": [r"cdn\.shopify\.com", r"Shopify\.theme"],
    "WordPress": [r"/wp-content/", r"/wp-includes/"],
    "Webflow": [r"data-wf-site", r"webflow\.js"],
    "Google Analytics": [r"googletagmanager\.com/gtag/js", r"google-analytics\.com/analytics\.js"],
    "Google Tag Manager": [r"googletagmanager\.com/gtm\.js"],
    "HubSpot": [r"js\.hs-scripts\.com", r"js\.hsforms\.net"],
    "Stripe": [r"js\.stripe\.com"],
}

def check(domain):
    base = f"https://{domain}"
    robots = RobotFileParser()
    r = requests.get(base + "/robots.txt", headers={"User-Agent": UA}, timeout=20)
    robots.parse(r.text.splitlines() if r.status_code == 200 else [])
    if not robots.can_fetch(UA, base + "/"):
        return {"domain": domain, "status": "robots_disallowed", "found": []}
    resp = requests.get(base + "/", headers={"User-Agent": UA}, timeout=20)
    html = resp.text
    found = [name for name, pats in SIGNS.items() if any(re.search(p, html) for p in pats)]
    gen = re.search(r'<meta[^>]+name=["\']generator["\'][^>]+content=["\']([^"\']+)', html, re.I)
    if gen:
        found.append("generator: " + gen.group(1))
    return {"domain": domain, "status": resp.status_code, "server": resp.headers.get("server"), "found": found}

print(check("pypi.org"))

Put your own contact link in the User-Agent. Site owners appreciate knowing who is calling.

This works for a handful of sites. At a few thousand, the fingerprint list becomes the real work: keeping patterns current, scoring confidence, reading versions, and handling redirects, timeouts and blocked sites without losing track of which is which.

A hosted option: Website Tech Stack Detector

Website Tech Stack Detector is an Apify Actor I built for lists. It uses the open fingerprint set, more than 7,600 technologies, and makes one homepage request per site, only when that site’s robots.txt allows it. You send up to 10,000 domains or URLs per run.

pip install "apify-client>=3.2,<4"
export APIFY_TOKEN=<YOUR_APIFY_TOKEN>

import csv, os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

with open("sites.txt") as f:
    sites = [line.strip() for line in f if line.strip()]

run = client.actor("conserving_celerytop/website-tech-stack-detector").call(
    run_input={"websites": sites, "maxSites": len(sites), "categories": ["CMS", "Ecommerce", "Analytics"]},
    max_total_charge_usd=Decimal("5.00"),
)

cols = ["domain", "status", "cms", "ecommerce", "analytics", "paymentProcessors"]
with open("tech_stack.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(cols)
    for row in client.dataset(run.default_dataset_id).iterate_items():
        w.writerow([row["domain"], row["status"]] + [", ".join(row.get(c) or []) for c in cols[2:]])

Leave out categories to get everything it finds. Each row has:

• technologies: every match with name, version when the page shows one, confidence from 0 to 100 and categories
• quick columns ready for a spreadsheet: cms, ecommerce, analytics, frameworks, cdn, hosting, paymentProcessors, tagManagers
• status: ok, or the reason a site was not checked, such as robots_disallowed, blocked, timeout or domain_not_found

The same run also works over plain HTTP with Apify’s run-sync-get-dataset-items endpoint, if you would rather not install the client.

What it costs

Store prices on September 27, 2026. Check the Store page before relying on them.

• $0.002 per website whose homepage loaded, which is $2 per 1,000, on the free and Starter plans. Scale pays $0.0018 and Business $0.0016.
• Apify’s start event adds $0.00005 per run for each GB of memory.
• Sites closed by robots.txt, blocked, timed out or not found cost nothing, and neither do duplicates or invalid entries.
• A site that loads but shows no known technology is charged, since the page was fetched and checked.
• Example: 500 domains where 460 load cost $0.92.

Honest limits

• One page, no JavaScript. It reads the homepage HTML and headers the server sends. Tools injected later by scripts can be missed. If you need those, run a headless browser, which costs more per site.
• Homepage only. A checkout platform used only on shop.example.com will not show on example.com.
• No usage history. It tells you what a site runs today, not when it switched or what it spends. Commercial databases that crawl the web continuously are the tool for “every site that used X since 2021”.
• robots.txt is respected. Some large sites disallow all bots, and those come back as robots_disallowed, free.

FAQ

Is there a free tech stack lookup API? For a few sites, a browser extension or a script like the one above is free. Most hosted APIs charge per lookup or per month.

Can I look up which companies use a technology? Not directly. Send a list of candidate domains and filter the results by technology. The Actor does not keep a crawl of the whole web.

Does it collect personal data? No. It reads public homepages once per site and does not store cookie values or personal data.

This article and the Actor are not affiliated with or endorsed by any company whose technology it detects. The fingerprint data is open source under GPL-3.0.

Greenhouse is the applicant tracking system behind the careers pages of a lot of tech companies. If you want those jobs as data, for a job site, a recruiting list or a sales signal, you do not need a Greenhouse account. Every public Greenhouse board has a read-only Job Board API that answers without a key.

This guide covers that free endpoint first, then what gets hard once you have more than a handful of companies.

Step 1: find the board token

Each Greenhouse board has a short name, called the board token. You can see it in the board link:

• https://boards.greenhouse.io/stripe has the token stripe
• https://job-boards.greenhouse.io/stripe is the newer host, same token

Many companies show their jobs on their own site instead. Open any job there and look at the link. A gh_jid= parameter means the page embeds a Greenhouse board, and the page source usually loads a boards.greenhouse.io/embed/job_board script whose for= parameter is the token.

Step 2: call the Job Board API

The list endpoint is https://boards-api.greenhouse.io/v1/boards/{token}/jobs. It returns every published job in one response, with no paging.

import requests

token = "stripe"
url = f"https://boards-api.greenhouse.io/v1/boards/{token}/jobs"
data = requests.get(url, params={"content": "true"}, timeout=30).json()

print(data["meta"]["total"], "open jobs")
for job in data["jobs"][:5]:
    print(job["title"], "|", job["location"]["name"], "|", job["first_published"], "|", job["absolute_url"])

When I ran this, Stripe’s board returned 702 jobs. Each job has id, title, location.name, first_published, updated_at, requisition_id and absolute_url. With content=true you also get content (the description as escaped HTML), departments and offices.

Two details that trip people up:

1. content is HTML with entities escaped, so run it through html.unescape before you parse it.
2. Pay ranges are not in the list. Request a single job with /jobs/{id}?pay_transparency=true and read pay_input_ranges. It is often an empty list, because many companies publish pay only in the description text.

That is all you need for one company. The API is public, documented by Greenhouse and fast. If you track two or three boards, stop here and write a small cron job.

Where it gets harder

The work grows once your list grows.

• Finding tokens. A list of 300 company websites does not come with board tokens. Some redirect to Greenhouse, some embed it, and some use a different system entirely.
• Other systems. In most real account lists, a good share of companies run Lever, Ashby, Workday or a European ATS such as Personio or Teamtailor. Each has its own endpoint and field names.
• New and closed jobs. The API shows what is open now. To see what changed since yesterday you have to store every run and diff it yourself.
• Normalizing. Location strings, remote flags, seniority and salary all come in different shapes.

You can build all of that. I did, and it took far longer than the first script.

A hosted option for many companies

I packaged that work as an Apify Actor called Greenhouse Jobs API. You give it board links, company websites or plain names and it reads the same public Greenhouse endpoint for each one, then returns one row per job in a fixed format.

You need an Apify account and its API token (Console, Settings, API & Integrations).

pip install "apify-client>=3.2,<4"
export APIFY_TOKEN=<YOUR_APIFY_TOKEN>

import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("conserving_celerytop/greenhouse-jobs-api").call(
    run_input={
        "companies": [
            "https://boards.greenhouse.io/stripe",
            "https://job-boards.greenhouse.io/dropbox",
            "figma.com",
        ],
        "titleIncludes": ["engineer"],
        "postedSince": "30 days",
    },
    max_total_charge_usd=Decimal("0.50"),
)

for row in client.dataset(run.default_dataset_id).iterate_items():
    if row["rowType"] == "job":
        print(row["companySlug"], "|", row["title"], "|", row["countryCode"], "|", row["postedAt"])
    elif row["rowType"] == "status":
        print(row["company"], "->", row["companyStatus"])

max_total_charge_usd is a hard cap on what the run can cost, which is worth setting while you test.

Every job row has the same fields: title, department, location, countryCode, workplaceType, seniority, jobFunction, salaryMin, salaryMax, salaryCurrency, postedAt, url and jobKey. jobKey stays the same between runs, so you can join runs on it. A company with nothing to return gets one status row, such as not_found or no_open_jobs, instead of silently disappearing.

Only new and closed jobs

Set "onlyNewJobs": true and give the watchlist a "monitorName". The first run returns everything. Each later run returns only jobs that are new since the last run (change: "new") and jobs that closed (change: "closed"). Save the input as a task in Apify, add a daily schedule, and you have a new-jobs feed without storing anything yourself.

What it costs

These are the free plan prices on the Apify Store on September 27, 2026. Check the Store page before you rely on them.

• Greenhouse Jobs API: $0.10 per company, which includes up to 1,000 of its open jobs ($0.09 on the Scale plan, $0.07 on Business). Each further 1,000 jobs of the same company is $0.045. A later check with onlyNewJobs is $0.002 per 1,000 open jobs on the board. So 100 companies cost $10 for the first full pull, and a daily onlyNewJobs check of them about $0.20. Descriptions cost nothing extra.
• ATS Jobs API, the multi-board version from the same author, reads Greenhouse plus Lever, Ashby, Workday and 18 other systems with the same input and output. It costs $0.045 per company with up to 1,000 jobs, less than the single-board version, so it is worth a look even for a Greenhouse-only list, and it is the one to use when your list mixes systems.

There are single-system versions for Lever, Ashby and Workday too. Paid Apify plans get lower per-company prices. Apify’s free plan includes $5 of monthly credit.

When not to use it

• One or two boards. The free endpoint above is simpler and costs nothing.
• Search across all companies. Neither the endpoint nor the Actor searches every Greenhouse board by keyword. You bring the list of companies. For keyword search across a fixed set of 824 startups and tech companies there is a separate Actor, Tech Jobs Search.
• Your own candidates or applications. That is Greenhouse’s Harvest API, which needs a key from the company’s Greenhouse account. The Job Board API only shows published jobs.

FAQ

Do I need a Greenhouse API key to read job postings? No. The Job Board API is read-only and public for published jobs. Keys are only for posting applications and for the Harvest API.

Is there a rate limit? Greenhouse does not publish one for the Job Board API. Be polite: one request per board per run, and cache the result.

Can I get jobs posted months ago that are still open? Yes. The API returns every open job, whatever its age. first_published tells you how old it is.

Greenhouse is a trademark of its owner. This article and the Actors are not affiliated with or endorsed by Greenhouse. The Actors read only jobs that companies publish on public boards, with no login.

Many large employers run their careers pages on Workday. Intel, Adobe and Salesforce are among them. If you searched for “Workday jobs API”, you probably want those open jobs as data, for a job board, a recruiting list or a sales signal. This guide covers what Workday offers outsiders, why a do-it-yourself scraper is harder than it looks, and a hosted option priced per company.

Two different things called “Workday API”

Workday’s official APIs (REST and SOAP Web Services) belong to the employer. You need an integration account inside that company’s Workday tenant, set up by its HR or IT team. They fit if you work there and want your own requisitions, not for reading other companies’ jobs.

Public career sites are what job seekers see, at addresses like https://intel.wd1.myworkdayjobs.com/External. Anyone can open them without logging in, but Workday publishes no documented jobs API for outsiders.

How a Workday career site link is built

Every link has three parts you need:

• the tenant, the company’s name in Workday (intel)
• the pod, a data center label such as wd1, wd5 or wd12
• the site name, the path after the host (External, external_experienced)

The site name matters: one company can run several sites, such as one for students and one for experienced hires. This parser pulls the three parts from any job or search link:

from urllib.parse import urlparse

def parse_workday_link(link):
    u = urlparse(link)
    host = u.hostname or ""
    if not host.endswith(".myworkdayjobs.com"):
        return None
    tenant, pod = host.split(".")[:2]            # "intel", "wd1"
    parts = [p for p in u.path.split("/") if p]
    if parts and len(parts[0]) == 5 and parts[0][2] == "-":
        parts = parts[1:]                        # drop a locale such as "en-US"
    site = parts[0] if parts else None           # "External"
    return {"tenant": tenant, "pod": pod, "site": site}

print(parse_workday_link(
    "https://adobe.wd5.myworkdayjobs.com/en-US/external_experienced/job/San-Jose/Senior-Engineer_R123"
))
# {'tenant': 'adobe', 'pod': 'wd5', 'site': 'external_experienced'}

To find a company’s link, open any job on its careers page. If the address contains myworkdayjobs.com, you have it; otherwise check the apply button’s link.

Why a do-it-yourself scraper takes longer than expected

Reading one site once is a weekend task. Keeping many sites running is not:

• The page is a JavaScript app. A plain HTTP request returns an empty shell, and the job list loads in pages.
• Dates are text. Lists say “Posted 3 Days Ago” or “Posted 30+ Days Ago”, so older jobs have no exact date unless you open each job.
• No salary field. Pay, when it is published at all, sits inside the description text.
• Locations are shortened. A job in three cities shows as “US Washington DC (+2 more)”.
• Large sites. Some employers list thousands of open jobs, and simple paging stops before the end.
• Each employer sets its own rules. Check the site’s robots.txt before you read it, keep requests slow, and skip sites that do not allow automated access.

None of this is impossible, but it repeats for every site you add and breaks quietly when a site changes.

A hosted option: Workday Jobs API

I packaged that work as an Apify Actor, Workday Jobs API. You paste career site links (or company websites that link to Workday) and get one row per open job in a fixed format, read live, and only where the employer’s robots.txt allows it.

You need an Apify account and its API token (Console, Settings, API & Integrations).

pip install "apify-client>=3.2,<4"
export APIFY_TOKEN=<YOUR_APIFY_TOKEN>

import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("conserving_celerytop/workday-jobs-api").call(
    run_input={
        "companies": [
            "https://intel.wd1.myworkdayjobs.com/External",
            "https://adobe.wd5.myworkdayjobs.com/external_experienced",
        ],
        "jobFunctions": ["engineering", "data"],
        "postedSince": "7 days",
    },
    max_total_charge_usd=Decimal("2.00"),   # a hard cap for this run
)

for job in client.dataset(run.default_dataset_id).iterate_items():
    if job["rowType"] == "job":
        print(job["title"], "|", job["location"], "|", job["postedAt"], "|", job["url"])
    else:
        print("status:", job["company"], job["companyStatus"])

Each job row has, among others:

Set includeDescription to true to add the description (with contact details removed), the tools it names, years of experience and any salary written in the text. A company with no matching jobs gets one status row that says why, such as no_matching_jobs or not_found.

Get only new jobs on a schedule

Add two fields and save the input as a task in Apify Console:

run_input = {
    "companies": ["https://intel.wd1.myworkdayjobs.com/External"],
    "onlyNewJobs": True,
    "monitorName": "workday-weekly",
    "alertWebhookUrl": "https://hooks.slack.com/services/...",   # optional
}

The first check returns the full list. Later checks return only jobs that are new or closed since the last one (change is new or closed) and can post an alert to Slack, Teams or any webhook. Schedule the task daily or weekly.

For one summary row per company, with open jobs, recent postings and counts per function, set outputMode to companies.

What it costs

On September 27, 2026 the Actor charged $0.10 per company, with up to 1,000 jobs included, on Apify’s free plan ($0.09 on Scale, $0.07 on Business). Prices can change, so see the Store page for the current price. How it adds up:

• $0.10 per company, also when a site lists no jobs or a website links no job board
• $0.05 for each further 1,000 jobs from one company
• $0.01 per started block of 200 descriptions, only when you ask for them
• $0.002 per later “only new jobs” check, per started 1,000 open jobs on the site

So 100 companies cost $10 for the first read, and a daily check of the same 100 about $0.20. Sites whose robots.txt refuses access, invalid links and duplicates are free. max_total_charge_usd is a hard cap.

Limits you should know

• It reads only Workday. For a list that mixes Greenhouse, Lever, Ashby and others, use ATS Jobs API, which reads 22 job board systems including Workday, at $0.045 per company.
• You bring the companies. It does not search all Workday employers. Paste links, websites, or pick a ready-made list.
• Salary comes from the text. Workday has no pay field.

FAQ

Is there an official public Workday jobs API? Not for outsiders. Workday’s documented APIs need credentials from the employer. Public career sites can be viewed by anyone, and this Actor reads what they show.

Can I get the recruiter’s name? No. Rows hold job data only, and contact details are removed from descriptions.

This article and the Actor are not affiliated with or endorsed by Workday, Inc. or any employer whose site it reads. Workday is a trademark of its owner.