Find Companies Using Greenhouse, Lever, Ashby & Workable

$2 / 1,000 verified-live companies · $0 to start · open-role counts included · re-verified at query time

Live status: https://api.apify.com/v2/key-value-stores/WickFeed~wickfeed-public-status/records/status.json — real self-test results for every wickfeed scraper (pass/fail plus 30-day success rate), updated hourly, no login needed. Opens as raw data (JSON).

Choose the right WickFeed tool

• Mixed hiring systems, or unsure which one a company uses → ATS Job Aggregator
• Greenhouse only → Greenhouse Jobs Scraper
• Ashby only, including published salary ranges → Ashby Jobs Scraper
• Workable only → Workable Jobs Scraper
• Need companies and live job counts, not job rows → ATS Company Discovery (this tool)

Ask "who uses Greenhouse — or Lever, Ashby, Workable, Recruitee — and who has open job postings right now?" and get back a clean list of real companies. Each one is re-checked live the moment you run it, with a current open-role count, sample job titles, and direct links to its careers page and public jobs API.

Your first result in four steps:

1. Try for free and sign in to Apify.
2. Leave the demo unchanged and click Start.
3. When the run finishes, open Dataset to see one row per company.
4. Click Export for CSV, Excel, or JSON.

Unofficial — not affiliated with or endorsed by Greenhouse, Lever, Ashby, Workable, or Recruitee.

Sources: Greenhouse · Lever (EU) · Ashby · Workable · Recruitee — 5 sources. (US Lever isn't covered — see below.)

In plain English — this is step one. It hands you a clean list of real companies that have open job postings right now. From there you do one of two things: reach out to them yourself (recruiting or sales), or hand the same list straight to the ATS Job Aggregator to pull and track their open jobs for you. Greenhouse, Ashby, Workable, and Recruitee results feed directly into the ATS Job Aggregator; EU-Lever results are discovery-only for now. Find the companies here; do the outreach or the job-tracking next.

Quick start

1. Pick the hiring systems you care about in the ATS dropdown — or choose All sources. The form starts on Greenhouse.
2. Set "Minimum open jobs" to focus on companies with real hiring volume (the form prefills 5), and optionally add job-title keywords like engineer or nurse to keep only companies hiring for that role.
3. Press Start. With Re-verify live on (the default), the run checks up to 25 high-volume candidates and returns the subset that is live and matches your filters — each with a current open-role count and sample titles — usually in well under a minute. Keyword searches, dead boards, and minimum-job filters can produce fewer than 25 results.

At $2 per 1,000 companies, a 25-company first run costs about $0.05, and your first runs are free on the Apify free plan. Export the results to CSV, Excel, JSON, or Google Sheets straight from the Apify Console — no code.

What it's for

• Recruiting / sales lead-gen — build a target list of companies that are actively hiring on a specific ATS.
• Job-board & aggregator seeding — get a verified list of live boards to pull jobs from (feed it straight into a job scraper, including our sibling actor ATS Job Aggregator).
• Market mapping — see who uses which hiring platform, and who has the most open job postings right now.

A 20-second worked example. Run it for Greenhouse with the keyword engineer. Back comes a row like Anduril Industries — 2,171 open jobs — careers link — jobs-API link. Open the careers page to inspect the company's public jobs — this actor does not provide contact details. A data team drops that row's ats + token into the ATS Job Aggregator and pulls every posting. Same row, either job done.

Why this one

The closest existing actor (igolaizola/greenhouse-companies) is Greenhouse-only and returns a static, pre-collected list with no guarantee a board is still live. This actor is different on the things that matter:

	This actor	Greenhouse-only benchmark
Sources	5 (Greenhouse, EU-Lever, Ashby, Workable, Recruitee)	1 (Greenhouse)
Freshness	Verified live at query time	Static list (may be stale)
Live open-job count	Yes (measured this run)	No
Sample job titles	Yes (≤5 per company)	No
"Companies hiring X" keyword filter	Yes (matches live job titles)	No
Provenance	Honest (public Common Crawl + our own live checks)	—

What "verified" means (read this)

• Bundled base list. The actor ships ~1,990 company boards. How we built it: we queried the public Common Crawl URL index (the CC-MAIN-2026-25 and CC-MAIN-2026-21 monthly crawls) for each vendor's board host pattern (e.g. boards.greenhouse.io/*, jobs.ashbyhq.com/*), extracted the board tokens, then confirmed every board live ourselves against its own public JSON API on 2026-07-15, keeping only boards returning at least one open job. No third-party curated company list was copied or repackaged — only the public archive index plus our own live checks. Breakdown: Greenhouse 872 · Workable 380 · Ashby 373 · Recruitee 300 · EU-Lever 65.
• Live re-verification (default ON). With reverify: true, the actor re-hits each company's own public API during the run and returns the fresh status, current open-job count, and current sample titles. A board that has since gone dead or dropped below your minimum is excluded from the results (it is not returned as a stale row) — so every returned company had open job postings live at the moment you ran it.
• Not magic. "Verified" means we successfully fetched that company's public jobs endpoint and it returned at least minJobs open jobs, right now. It does not mean anything about private/internal reqs or data the company doesn't publish.

Is this allowed?

Everything this actor reads is public — the same job data a company already publishes on its own careers page, fetched from each vendor's public JSON API. No login, no password-walled data, no HTML scraping, no private or candidate information. We don't make any legal claim about how you use the results — but there's no gated or hidden data involved here, only what employers put out in the open. Use the company lists for hiring research and lead-gen, not spam.

Input

{
  "ats": ["greenhouse"],
  "minJobs": 5,
  "keywords": ["engineer"],
  "maxResults": 25,
  "reverify": true,
  "discoverFresh": false
}

Field	Type	Default	Notes
ats	string[]	["greenhouse"]	Which hiring systems to search. The form and a bare API call with no input both start on Greenhouse; choose All sources or pass ["all"] to search every platform. Any of greenhouse, lever-eu, ashby, workable, recruitee, or all (as array items). US Lever (jobs.lever.co) isn't offered — it's robots-blocked in the archive we build from, so there's no clean bundled list; use lever-eu for Lever. If every system you name is unsupported, the run stops with a message listing the valid choices.
minJobs	integer	5	Only return companies with at least this many open jobs posted right now. The form and a bare API call both start at 5; lower it to 1 to include any company with at least one open posting.
keywords	string[]	[]	Keep only companies with at least one open job whose title contains any of these words (case-insensitive) — e.g. ["engineer"] → companies hiring engineers. Needs reverify: true (titles are read during verification): setting keywords with reverify: false stops the run with a plain-English message rather than billing you for an unfiltered snapshot list.
maxResults	integer	25	How many boards this run checks — not a scan of all ~1,990. It takes the top N boards by their stored (build-date) job count and checks only those live. So a keyword search searches only those top N boards: a zero result means "none of the top N matched", not "nobody matches" — raise this to search deeper. It is also your cost ceiling ($0.002 per returned company: 25 ≈ $0.05, 1,000 ≈ $2, 5,000 max ≈ $10). The run returns the subset of those boards that is live and matches your filters, so keyword searches, dead boards, and minimum-job filters can produce fewer results than N.
reverify	boolean	true	ON: re-check every company live now (fresh status, count, titles). OFF: return the bundled list from our stored snapshot — instant, no network, but the counts are the build-date snapshot, each row reports live: null and verifiedAt: null (not re-checked this run) with snapshotAt set to the build date, and there are no titles or keyword filtering.
discoverFresh	boolean	false	ON: also search the public Common Crawl archive at runtime for company boards not already in the bundle, then verify them live. Finds newer companies but is slower and depends on the archive being reachable. Needs reverify: true.

Default first run (form prefill and a bare API call with no input): ats: ["greenhouse"], minJobs: 5, maxResults: 25, reverify: true → the run checks up to 25 high-volume candidates and returns the subset that is live and matches your filters, each with a live job count, usually in well under a minute. Keyword searches, dead boards, and minimum-job filters can produce fewer than 25 results.

Output

One record per verified-live company, pushed to the dataset. Real example (from a live run):

{
  "ats": "greenhouse",
  "token": "andurilindustries",
  "company": "Anduril Industries",
  "jobCount": 2171,
  "live": true,
  "apiUrl": "https://boards-api.greenhouse.io/v1/boards/andurilindustries/jobs",
  "careersUrl": "https://boards.greenhouse.io/andurilindustries",
  "sampleTitles": [
    "2026 Early Career Electrical Engineer",
    "2026 Early Career Engineering Finance Associate",
    "2026 Early Career Finance Coordinator",
    "2026 Early Career Flight Test Engineer, Altius",
    "2026 Early Career Manufacturing Engineer"
  ],
  "verifiedAt": "2026-07-15T19:22:01.680Z",
  "snapshotAt": null,
  "schemaVersion": 1
}

Field	Type	Meaning
ats	string	Which system, one of: greenhouse, lever, lever-eu, ashby, workable, recruitee.
token	string	The company's board id in that system (the slug/subdomain). Pass this + ats straight into the ATS Job Aggregator's sources to pull the jobs.
company	string or null	Best-effort display name. Falls back to a title-cased token when the API exposes no name — always for Lever, sometimes for Ashby.
jobCount	integer	Open jobs on the board. Measured live as of verifiedAt when re-verified; the build-date snapshot count as of snapshotAt when reverify: false.
live	boolean or null	Whether the board is live now. With reverify: true every returned record is true (dead boards are dropped). With reverify: false it is null — we didn't re-check it this run, so we don't claim it's live now (snapshotAt says when it last was).
apiUrl	string	The board's public JSON jobs endpoint — GET this to pull the actual postings (or feed it to a job scraper).
careersUrl	string	The human-facing public careers page.
sampleTitles	string[]	Up to 5 current open-job titles (empty when reverify: false).
verifiedAt	ISO string or null	When this company was verified this run. null when reverify: false (nothing was re-checked this run — see snapshotAt).
snapshotAt	ISO string or null	The build date our bundle last confirmed this board live. Set when reverify: false; null on rows re-verified live this run.
schemaVersion	number	The output-record schema version (currently 1). See Output contract below.

Output contract (schema stability)

Your pipeline shouldn't break because we shipped an update, so here's the promise in writing:

• We never rename or remove an existing field within a major version. The fields above — ats, token, apiUrl, careersUrl, and the rest — keep their names and their meaning. Build on them safely.
• A null is honest, not missing. Where a system exposes no display name, company is present and set to null (or a title-cased token) — never dropped, so a field you read is always there.
• New fields are added, never forced. We may add a field over time; adding one never touches the fields you already read, so your existing code keeps working untouched.
• A breaking change is loud, not silent. If a field ever had to be renamed or removed, that's a major version bump, called out in the Changelog (and the Issues tab) before it lands — never a surprise on your next scheduled run.
• schemaVersion is a breaking-contract version, not a shape fingerprint. Every record carries it (it's in RUN_SUMMARY too). It bumps only when an existing field is renamed, removed, or its type changes — the things that would break code you already wrote. Adding a new field does not bump it (adding one never touches the fields you read). So schemaVersion doesn't promise "the exact set of fields is frozen"; it promises "everything you already read keeps its name and meaning until this number changes." It's 1 today.
• One honest note for reverify: false (snapshot mode). As of 0.1.12, snapshot rows report live: null and verifiedAt: null (they were not re-checked this run) and carry snapshotAt (the build date they last were live) — the earlier build reported a misleading live: true / this-run timestamp here. If your pipeline consumed reverify: false output and assumed live was always a boolean, add a null check. This corrects a mislabeling; the default reverify: true contract is unchanged (live is always true, verifiedAt always an ISO string there), so schemaVersion stays 1.

Run summary

The dataset holds company records only. A run summary is saved to the key-value store as RUN_SUMMARY (candidate counts, how many were re-verified, and how many were dropped and why — dead, below-minimum, no keyword match, error). Records that fail internal validation go to REJECTS with reasons — never silently dropped.

Pricing

Pay-per-event:

• company-found — per company returned: $2.00 per 1,000 companies. Starting a run costs $0. With Re-verify live on (the default) you pay only for companies confirmed live with open job postings at query time — dead or below-minimum boards are dropped and never billed. With Re-verify live off you pay the same rate for each stored-snapshot row returned (build-dated, snapshotAt marks the date, not re-checked this run) — cheaper on time, but not re-verified, so prefer the default when you're paying to know a board is live now.

First run free. The default 25-company run costs about $0.05, and Apify's free plan covers your early runs — so trying it is effectively free.

Price anchor. The closest thing on the shelf (igolaizola/greenhouse-companies) is Greenhouse-only and returns a static list. Its price is tiered by your Apify plan: $1.00 per 1,000 on the Free tier, dropping to $0.70 per 1,000 only on the Gold tier and above, plus a per-run start fee (prices checked 2026-07-16). This actor is $2 per 1,000 with $0 to start at every tier — because a record here is a live-verified company with a current open-role count (who to sell to, who to aggregate) across 5 sources, not a single static row, and dead boards are never billed.

If a charge ever looks wrong, open an issue on the Issues tab with your run ID — we investigate the same day, and if we over-billed you we file a credit request with Apify to put it back on your account. (Apify pays seller compensation as account credit rather than cash, so that's what we can promise and what we'll do — not a guarantee about how Apify itself handles it.)

Limitations (read this)

• Public boards only. This reads the job data a company chooses to publish. No private/authenticated ATS data, internal reqs, or candidate data.
• Company discovery is bundle-first. No ATS lets you enumerate every customer. The bundled ~1,990 verified boards are the base list; discoverFresh adds a best-effort live search of the public archive for boards not yet in the bundle.
• US Lever is not covered. jobs.lever.co is robots-blocked in Common Crawl, so there is no license-clean bundled list. EU-Lever (jobs.eu.lever.co) is covered.
• maxResults is a top-N-boards budget, not a full-corpus scan. A run checks only the top maxResults boards by their stored (build-date) job count (biggest first) and returns the live subset — it does not search all ~1,990 boards. So a keyword search's zero result means "none of the top N matched," not "nobody matches" — raise maxResults to search deeper. Each returned company is $0.002, so cost scales with it: 200 ≈ $0.40, 1,000 ≈ $2, the 5,000 maximum ≈ $10.
• discoverFresh shares the budget so fresh boards aren't starved. Newly-crawled boards have no stored job count, so a plain biggest-first cut would sort them behind every sized bundled board and never check them. To give them a fair shot, a fresh-discovery run reserves up to half of maxResults for fresh boards (whichever side has fewer donates its slack to the other). The total still never exceeds maxResults, so your cost ceiling is unchanged.
• Boards churn by the minute. A board can be live when the run starts and gone an hour later — that's exactly why reverify exists. verifiedAt records the moment we checked.
• Rate & politeness. ≤2 requests/second per host, with retries and backoff; hosts run in parallel. Large runs take proportionally longer by design.
• Memory & response size. Runs on a 512 MB floor; each HTTP response is capped at 30 MB (env ATS_MAX_RESPONSE_BYTES). An over-size or unreachable board is dropped for that one company, never the whole run.

FAQ

What do I get back, exactly? One row per company that has open job postings live right now on the ATS you picked — with its board token, a current open-role count, up to five sample job titles, and links to its careers page and public jobs API. Not job rows; companies.

How is this different from a job scraper? A job scraper needs to know which companies to pull from. This actor answers that first question — who uses this hiring system and has open job postings right now — and hands you the list. Point a scraper at that list next (see the chaining recipe below).

Do I need proxies or a login? No. These are public vendor APIs — the actor calls them directly, the same request a browser makes when it loads a careers page. No account, no password-walled data.

How fresh is the list? Every returned company is re-checked the moment you run it (reverify: true, the default), so the status, count, and titles are live. The bundled base list was last confirmed live on 2026-07-15; turn reverify off for an instant, network-free snapshot of that build instead.

How do I find companies hiring for a specific role? Add job-title keywords (e.g. ["engineer"]) with reverify on — you'll get back only companies that have at least one open job whose title matches.

Why isn't US Lever covered? jobs.lever.co is robots-blocked in the public Common Crawl archive we build the base list from, so there's no license-clean way to ship US Lever boards. EU-Lever (jobs.eu.lever.co) is covered.

I got few or zero companies back — is it broken? Almost never. Companies are dropped (and never charged) when a board has since gone dead, fell below your "Minimum open jobs", or had no open title matching your keywords. First, widen the net: lower "Minimum open jobs", clear the job-title keywords, or add more hiring systems — then check the run's Status and Logs. If it still looks wrong, open an Issue and include your run link. Advanced diagnostics: the full breakdown — how many boards were dead, below-minimum, no-keyword, or errored — is written to the run's key-value store as RUN_SUMMARY.

Can AI agents use this? Yes — it's callable through Apify's hosted MCP server at mcp.apify.com by Claude Desktop, Cursor, n8n, LangGraph, CrewAI and other MCP clients. See Use with AI agents (MCP) — including a ready-made recipe to chain it into the job aggregator.

Use with AI agents (MCP)

This actor is callable as a tool by AI agents — Claude Desktop, Cursor, VS Code, n8n, LangGraph, CrewAI, or any MCP-compatible client — through Apify's hosted MCP server at mcp.apify.com. Agents find it with search-actors, inspect its input with fetch-actor-details, and run it with call-actor. Nothing to install or host on our side.

Point your MCP client at Apify's server:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

That form uses OAuth sign-in. To pass a token instead, add a header:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}

The output is flat, stable JSON built for machine consumption, and agentic pay-per-event billing is enabled.

Chain it: discover companies → pull their jobs (agent recipe)

This actor is the front door to the whole toolkit. It emits one record per company carrying an ats and a token — exactly the two fields the sibling ATS Job Aggregator reads in its sources input. So an agent can run a two-step pipeline with no human in the middle:

1. Discover — call-actor wickfeed/ats-company-discovery:

   { "ats": ["greenhouse"], "minJobs": 5, "keywords": ["engineer"], "maxResults": 50 }
   

   Each returned record looks like { "ats": "greenhouse", "token": "andurilindustries", "jobCount": 2171, ... }.

2. Pull the jobs — take the ats + token from each company and pass them straight into the aggregator's sources, then call-actor wickfeed/ats-job-aggregator:

   {
     "sources": [
       { "ats": "greenhouse", "token": "andurilindustries" },
       { "ats": "greenhouse", "token": "stripe" }
     ],
     "maxResultsPerSource": 50
   }
   

   Turn on the aggregator's diffMode and put it on a daily Apify Schedule to monitor those same companies — paying only for new postings, and $0 on a quiet day.

One honesty note for the chain. Greenhouse, Ashby, Workable and Recruitee tokens map 1:1 — drop them straight into sources. EU-Lever (lever-eu) is discovery-only: the aggregator's Lever reader uses the US endpoint (api.lever.co), so skip lever-eu rows when you hand the list over. The aggregator bundles 4 of those 5 systems (Greenhouse, Ashby, Workable, Recruitee); its Lever is bring-your-own for now.

Changelog

• 0.1.13 — 2026-07-16 — Added a public live-status link (real self-test results, no login).
• 0.1.12 — 2026-07-16 — Honest snapshot mode, machine-readable output schema, and clearer controls. reverify: false (snapshot) rows now report live: null and verifiedAt: null (they were not re-checked this run) and carry a new snapshotAt field (the build date they last were live) — replacing the earlier misleading live: true / this-run timestamp; the default reverify: true contract is unchanged, so schemaVersion stays 1. Setting job-title keywords with reverify: false now stops the run with a plain-English message instead of billing you for an unfiltered snapshot list. Fresh discovery (discoverFresh) now reserves up to half of maxResults for newly-crawled boards so they aren't starved behind the big bundled ones (total still capped at maxResults). A real machine-readable dataset field schema was published so generated clients can discover the row shape. Docs: schemaVersion is described as a breaking-contract version (additive fields don't bump it), the maxResults control is labeled a top-N-boards budget (a keyword search scans only the top N boards, so a zero result isn't "nobody matches"), the provenance note is now plain text (no dead relative link), the array-form "ats": ["all"] example is used everywhere, and the competitor price anchor is dated and tier-labeled.
• 0.1.9 — 2026-07-16 — Fail-closed input, aligned defaults, and honest wording. An input where every hiring system you chose is unsupported (for example only US lever) now stops the run with a plain-English message listing the valid choices, instead of quietly widening the search to all five systems — a list with at least one usable system still runs on that system and just notes the ones it ignored. A bare API call's Minimum open jobs default is now 5, matching the Console form (both were already Greenhouse-only). Copy updates: "open job postings right now" replaces the older "confirmed hiring" wording, the Console/API defaults are stated exactly, the result cap is described accurately (the run checks up to 25 candidates and returns the live subset that matches your filters, so you can get fewer than 25), the discovery→aggregator handoff notes up front that EU-Lever is discovery-only, and a four-line first-result path plus a tool chooser were added near the top. No change to the output record.
• 0.1.8 — 2026-07-16 — Output contract + safer first API call. Every company record now carries a schemaVersion field (currently 1), and this README documents the output contract (existing fields are never renamed or removed within a major version; null means honestly-absent, not missing) — additive, so existing pipelines are unaffected. A bare {} API call now mirrors the Console prefill (searches Greenhouse, the prefilled system) instead of quietly searching all five — the returned count is still capped by Max results (default 25 ≈ $0.05), so a first call can't surprise-bill. To search every system, pass "ats": ["all"] (or pick the systems you want); an explicitly-cleared selection still means all sources.
• 0.1.0 — Initial build. Five-source live verification (Greenhouse, EU-Lever, Ashby, Workable, Recruitee), ~1,990 bundled verified boards, query-time re-verification with live job counts + sample titles, keyword ("companies hiring X") filter, optional Common Crawl fresh discovery, per-host rate limiting + retries/backoff, schema validation with REJECTS, run summary, pay-per-event charging.

---

Worth re-running. Boards go live and dead constantly, and companies cross your "minimum open jobs" line week to week. Re-run this on a schedule to catch newly-hiring companies and drop the ones that have gone quiet — every run re-checks live, so your list never silently goes stale. (One-off research needs a single run; an always-current target list is the reason to schedule it.)

Got your company list? Pull every open job with the ATS Job Aggregator ($1/1k jobs) — and turn on its diff mode to track only new postings across those boards on a daily schedule, paying only for what changes (and $0 on a quiet day). A 2-step, pay-as-you-go pipeline: discover the companies here, then monitor their jobs there.

Need help? Open an Issue with your run link. If a run misbehaves or a charge looks off, open the Issues tab with your run ID and we'll look into buyer-facing breakages the same day.