Greenhouse Jobs Scraper: All 5 ATS Boards

What does Greenhouse Jobs Scraper do?

Greenhouse Jobs Scraper reads the public job boards of Greenhouse, Lever, Ashby, Workable and Recruitee. You give it company names, careers-page URLs or slugs, and it finds each board itself. Every posting comes back to you with the same fields: title, employer, place, department, team, pay where published, the apply link and the full posting text. It costs you $1.20 per 1,000 postings, $0.65 on the Apify Store's Gold plan and above, and a miss comes back as a free row.

Give it a company name or a careers-page URL and it finds the board itself. Or start from a preset list of AI, fintech, developer-tool or large tech companies. On a schedule it returns you the postings new since your last run, plus the ones that closed or moved. Logins, API keys and browsers stay out of it.

The prefilled default reads Ramp's board:

{
  "company": ["ramp"],
  "maxItemsPerCompany": 100
}

Who uses Greenhouse Jobs Scraper

Who	What they run it for
Talent intelligence and aggregators	Every open role across your company list, in one table with one shape, whichever of the five boards each uses.
Recruiters and sourcers	Your target list's live postings with apply links and published pay, and what is new since last week.
Sales and hiring-signal work	Which roles a company you watch opens, in which department, where, and at what pay.
Agents and pipelines	Your company names in, the same columns out, whichever of the five boards answered.

Features

• Workable postings in the same rows as Greenhouse, Lever, Ashby and Recruitee: one run covers a list that mixes all five boards.
• The board found from a name. A company name or careers-page URL is enough; it tries the likely slugs on all five boards until one answers.
• Preset company lists: AI startups (21), fintech (12), developer tools (16) and large tech (14). Each board is checked on its board's public feed.
• Filters keep what you want. Keep the postings that publish pay; drop the roles or places you do not want by title, department, location, remote status, date or type.
• New and closed postings: a scheduled run returns what appeared since your last run, plus the postings that left the board or changed.
• Pay read where published: pay the board publishes, or a range read from the posting text, with on-target earnings flagged.
• Plain-text description: the posting as clean text beside the board's own version, on every board.
• Seniority and places split out: the level from the title, and city, region and a two-letter country code where one resolves.
• Team beside department: Ashby and Lever rows carry the team inside the department.

Why this one

The most-used alternative on the Store, run on the same input as the example below (Ramp's Ashby board) on 2026-09-25:

	This Actor	Most-used alternative
Postings returned	100	10
Price per 1,000 postings	$1.20	$1.50
Start charge per run	$0.00005	$0.00005
Default run memory	256 MB	1,024 MB
Workable boards in the same rows	✔️	❌

On the shared board both tools filled the title, pay range, employment type and remote status on every posting they returned. The differences are the reach, the price and the memory. We also read a removal list before every run. A misspelt company returns a row that names it.

How much does it cost?

$1.20 per 1,000 postings, $0.65 on Gold and above. The platform charges two events:

Event	Price	When
listing-returned	$0.0012	one posting written to your dataset
apify-actor-start	$0.00005	once a run, per GB of memory (one at the 256 MB default)

On Apify's paid Store plans (Bronze, Silver, Gold and up) the posting price steps down. It is $0.00101 on Bronze ($1.01 per 1,000), $0.00082 on Silver ($0.82) and $0.00065 on Gold, Platinum and Diamond. Status rows, entry notes and dropped duplicates are unbilled. A posting your filter drops is dropped before it can cost you anything.

Postings written	You pay
100	$0.12
1,000	$1.20
10,000	$12.00

Platform compute is billed separately by Apify. A run of 100 postings on Ramp's board returns 100 rows at the default memory; on Workable each posting you keep adds a request.

How do I use Greenhouse Jobs Scraper?

1. Open the Actor on Apify and press Start. The default input reads Ramp's board.
2. Add your companies, one entry each. A name, a careers-page address or a board address all work. A preset list works too.
3. Set the filters and caps you want, and the new or closed postings switches for a schedule.
4. Open your dataset; the run's summary holds your counts.

Input

Input	Type	Default	What it does
company	list of strings	["ramp"]	One entry per company: name, careers-page URL, slug, board:slug or board URL
preset	choice	(none)	A bundled company list: ai-startups 21, fintech 12, devtools 16, top-tech 14
maxItemsPerCompany	integer	100	Most posting rows per company; each board caps on its own
maxItems	integer	(none)	An overall cap on the whole run, on top of the per-company one; leave it empty for all of them
onlyNew	boolean	false	Skip postings an earlier run under your account returned
reportClosed	boolean	false	Report postings that left a board, or changed, since its last run
memoryName	string	(empty)	A name you pick for the list of postings an earlier run already returned; up to 20 letters, digits or hyphens
includeDescription	boolean	true	Workable's posting text is a request per posting; off is a title-and-link pass with its description columns null

Only new since my last run skips what an earlier run under your account returned. Report closed postings watches a board's open postings — URLs, apply links, titles, departments, teams, locations and the remote flag, never pay or descriptions — so a posting that left or changed comes back naming it. Both keep their lists in a store under your account; delete it to start over. With neither Companies nor a preset list, the run reads Ramp's board.

company

One entry per company, in any of these forms:

• A company name (Hugging Face, Scale AI): builds the likely slugs and tries them on all five boards.
• A careers-page URL or domain (careers.bunq.com, stripe.com): tries the domain's name as a slug on every board; the page itself is not fetched.
• A slug, bare or tagged (ramp, greenhouse:stripe): a bare slug tries each board in turn; board:slug pins the board when two share one. Find a slug in any job's address on the company's careers page (jobs.ashbyhq.com/ramp gives ramp).
• A board URL (jobs.ashbyhq.com/ramp, boards.greenhouse.io/stripe, jobs.lever.co/zoox, apply.workable.com/nuvei, bunq.recruitee.com): read directly; the boards' API URLs work too.

Entries pointing at private hiring APIs, access tokens or login cookies get a refusal.

The filters

Filter	What it keeps
Title, department, location	Postings whose text matches, case-insensitively; the title and location filters each take an exclude list too
Posted within the last N days	The date the board states; a posting with none is dropped
Remote only	Postings the board marks remote — on Greenhouse the flag is inferred from the location's wording
Employment type	full_time, part_time, contract, intern, temporary, from each board's wording; Greenhouse publishes none
Published pay only	Postings with a pay value; on Workable one request per posting

A posting a filter removes is excluded before billing.

What data does Greenhouse Jobs Scraper return?

The default run returned 100 postings on Ramp's board; the board listed 146. One of them, kept to the fields a buyer reads first:

{
  "platform": "ashby",
  "official_url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "title": "Security Engineer, Cloud",
  "posted_date": "2026-04-07T17:12:35.753+00:00",
  "location": "New York, NY (HQ)",
  "is_remote": false,
  "workplace_type": "Hybrid",
  "description": "ABOUT RAMP\n\nRamp is building the smart infrastructure for finance teams.",
  "salary_minimum": 211400,
  "salary_maximum": 290600,
  "salary_currency": "USD",
  "salary_text": "$211.4K - $290.6K",
  "pay_interval": "year",
  "has_equity": true,
  "company_name": "Ramp",
  "apply_url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
  "city": "New York City",
  "region": "NY",
  "country": "US",
  "employment_type": "full_time",
  "row_type": "ROW"
}

Fields on every posting row

Every value is the board's own: a field the board leaves out stays null, and the few fields the Actor derives (a company name from the slug, a level read from the title, a cleaned employment type, the split city/region/country, the resolved country code, the remote flag on Greenhouse, the cleaned description text) say so beside them.

Field	What it carries
title, company_name, official_url, apply_url	the job's title, the employer's name (a slug in title case where none is published), the posting's public URL, and where a person applies
posted_date, location, city, region, country, is_remote, workplace_type	when it went up; the workplace as published, split into city, region, country; the board's remote mark; remote, hybrid or onsite
description, description_text	the full posting text as published, and the same text as clean plain text
job_type, employment_type	the employment type in the board's words, and cleaned to full_time, part_time, contract, intern or temporary
department, team, job_id, company_slug, platform	the department or the team when none is given, the team inside it, the board's posting id, the slug that answered, and which board answered
salary_minimum, salary_maximum, salary_currency, salary_text, pay_interval, has_equity, salary_is_ote, compensation	the published pay: the range and its currency, the range as written, its interval, equity and on-target-earnings flags, and the board's own pay object unchanged
address	the board's structured location, unchanged
seniority	the level the title states, else null

Pay. Ashby, Greenhouse, Lever and Recruitee publish it as fields. On Greenhouse and Workable a pay range is read out of the posting text, and commission-inclusive pay is marked. Location splits a plain text into city, region and country where the board gives none. Seniority reads the title in English, German and French.

Output

A posting row carries every field above; a value the board leaves out is null, and a duplicate posting URL is dropped before charge. Only postings are billed — any entry that fails still returns a free row saying why:

row_type	status	When it appears
ROW		a posting
ITEM_STATUS	vendor_not_read	the entry names a board outside the five, or a board that asked to be left out
ITEM_STATUS	read_refused	the board refused or failed the read: a block page, a refused request, a redirect or a cut-off answer
ITEM_STATUS	no_board_found	no board answers for the entry
ITEM_STATUS	posting_closed or posting_changed	the closed-postings switch: a posting gone, or a watched field moved
ITEM_STATUS	no_postings	the board was read and had nothing to return: empty, removed or filtered away
NO_MATCHING_LISTINGS		every board answered and nothing matched
STOPPED_EARLY		your spending cap ended the run
run entry	RUN_SUMMARY	end of every run, in your default key-value store, with the totals

A refused read keeps the postings already returned from that board.

Use Greenhouse Jobs Scraper with AI agents

claude mcp add --transport http apify "https://mcp.apify.com?tools=Pradio/greenhouse-lever-ashby-job"

Paste that line to give an MCP client this Actor as a tool. Runs and datasets also plug into the platform's integrations — Zapier, Make and n8n.

Personal data and limits

• Postings, not people. Each row describes a job posting: no field pulls a person's name, email or phone out of the posting text, and a name an employer wrote into a posting stays inside it. Descriptions are the employers' own adverts.

• You are the controller. You need a lawful basis for keeping and using the rows (legitimate interest under the GDPR or the UK GDPR, for example). They are for reading and aggregation, not for training AI models or profiling the people a posting names. Lever and Workable ask that their postings not train AI models; Lever also reserves a legal right over its postings.

• The public source is named. Every posting row carries platform, official_url and company_slug; a row for an entry with no board names it in subject instead.

• Public feeds only. It reads the five boards' public job-board feeds; private hiring APIs, apply forms, shared logins and careers-site pages stay out of scope, and a feed that redirects elsewhere is refused. Lever is read at most once a second, as its site rules ask, and a feed the rules disallow is skipped and its row says why. A refused board gets one row saying so, and nothing asks it again that run under any identity or proxy.

• Objection route. Run a job board, or named in a posting? Open an issue on the Actor's Issues tab with the board, the posting URL or your name. It goes on a removal list every run reads first. A removed board returns one uncharged ITEM_STATUS row (status vendor_not_read), and a posting whose title or description carries a listed name is dropped.

• SmartRecruiters, Personio, Workday, iCIMS and Taleo have no logged-out feed it reads; an entry naming one returns a row saying so.

• A company name is a best guess on the slug; check the employer name on the rows and tag the slug when it matters.

• A schedule's memory keeps posting URLs and labels; pay and descriptions stay outside it by rule.

Greenhouse Jobs Scraper is an independent tool, not affiliated with, endorsed by, or maintained by Greenhouse Software, Lever (Employ Inc.), Ashby, Workable, SmartRecruiters, Recruitee, or any employer whose public job board you request. Job content belongs to the posting company.

Troubleshooting

The wrong company answered? Two boards can know the same slug. Check the employer name on your rows, then pin the board with board:slug (greenhouse:stripe).

A company name found nothing? Its board's slug differs from its name. Open one of the company's jobs, read the slug out of its address and pass it as board:slug.

FAQ

Can I run it on a schedule?

Yes — add one in the Apify Console with a cron such as 0 7 * * * and pick this Actor. With the new-since-last-run switch on, each scheduled run returns what appeared since you last ran it.

Do I need a proxy or an API key?

Neither — the boards answer a plain logged-out request over a direct connection, and a board that refuses returns a row naming it.

What formats can I download the rows in?

JSON, CSV, Excel, XML or an HTML table, from the Console or the API.

How many jobs can I get per run?

Every posting a board lists, capped per company (default 100) and across the run if you set one.

How much does it cost to scrape job boards?

$0.0012 per posting written, $0.00065 on Gold and up — the pricing section above gives the full bill; a company with no postings writes no billed rows.

How do I report a bug or ask for a feature?

Open an issue on the Actor's Issues tab with the input you ran and the run link. The same tab takes removal requests from a board owner or a person named in a posting.

Is it legal to scrape the boards?

It reads the boards' public logged-out feeds — no private APIs, no recruiter emails. Having the right to read the boards you give it, and how you use the rows, is yours; a block stops the read. Personal data covers use of the rows. This page is not legal advice.

Can I call it through an API?

Yes. The Apify API runs it and returns the dataset as JSON, and the AI-agents section above gives the MCP setup.

What if a field comes back empty?

That is the board's answer. The field stays null rather than going missing, and the features list and the field notes name the few fields a board never publishes.

See also

• YC Jobs Listings Scraper: roles on Y Combinator's Work at a Startup board.
• Authentic Jobs Scraper: design, development and remote roles on the Authentic Jobs board.
• Companies House New Companies Scraper: this week's new UK incorporations, for hiring-signal users who also watch new companies.