ATS Jobs Unified Lookup: Unified ATS Job Scraper (Greenhouse, Lever, Ashby & More)

You give this actor a company slug — stripe, or a full board URL from any of six platforms — and it checks Greenhouse, Lever, Ashby, Workable, SmartRecruiters, and Personio for a live job board, in parallel, without you having to know in advance which one the company actually uses. Two output modes cover two different jobs: jobs mode (the default) returns every open role it finds, normalized to the same fields regardless of which platform hosted them, so you can see every open role wherever it's posted. signal mode collapses the same lookup into one flat row per company — open-role counts, hiring by department, and 30-day hiring velocity — built for scoring an outbound list rather than reading job titles one by one.

Who it's for

The accountable_eel catalogue sells company intelligence columns for outbound. Each actor takes a list of domains or company identifiers and returns one flat, stably-named row per input — firmographics, registry IDs, tech stack, email route, hiring activity — the shape a Clay table, an n8n workflow, or an AI agent can consume without post-processing. Pricing is pay-per-event and per-domain: a few tenths of a cent for a row that was actually found, and nothing for a miss, so a list that doesn't enrich costs you next to nothing. Where an official source exists — VIES, GLEIF, SEC EDGAR, Brønnøysund, PRH, RDAP — it is queried directly instead of scraped. No seat licence, no monthly minimum, no credit system to decode.

For this actor specifically: instead of picking one of six single-platform lookup actors and hoping you guessed right, you check all six ATS platforms in a single call and pay only for the one (or two) that actually match.

Why this one

• One slug, six platforms, tried in parallel. You don't have to guess which ATS a company uses before you can get its jobs.
• Two shapes for two jobs. The full posting list when you need actual roles, or one aggregated row per company when you're scoring a list — same input, one mode field switches between them.
• Billed only for what resolves. A platform that doesn't match a company (typically five of the six) costs nothing; you pay per match, not per guess.
• Departments aren't blank for the platform most companies actually use. Greenhouse's job-list endpoint omits departments entirely, so this actor makes a second request to fill them in — without it, department and roleCountsByDepartment would be null for every Greenhouse company.
• Migrations don't get dropped. A company mid-move between two ATS platforms still resolves correctly — both boards land in the same row instead of one being silently discarded.

What you get

Job-list mode fields

One row per company slug. Each of the six platform columns is present only when that platform matched; a platform that didn't match is simply absent from the row, and was never billed for that company.

Each platform's jobs[] array holds the same normalized shape, whichever platform it came from:

In jobs mode, each platform's list is capped at 100 postings per company — a company matches and bills the same either way, just with the first 100 listed if their board is bigger.

Signal mode fields

Set "mode": "signal" and every platform hit for a company collapses into one row instead of a nested list per platform:

{
  "query": "warp",
  "found": true,
  "status": "OK",
  "atsDetected": true,
  "atsPlatform": "ashby",
  "atsPlatforms": ["greenhouse", "ashby"],
  "openRoles": 23,
  "postingsSampled": 23,
  "roleCountsByDepartment": {
    "Customer Success": 6, "Growth": 5, "Sales": 5, "Engineering": 4, "Finance": 2, "Design": 1
  },
  "hiringFor": {
    "sales": { "hiring": true, "count": 5 },
    "engineering": { "hiring": true, "count": 5 },
    "marketing": { "hiring": true, "count": 4 },
    "customer-success": { "hiring": true, "count": 2 },
    "executive": { "hiring": true, "count": 2 }
  },
  "newestPostingAt": "2026-08-20T20:21:41.000Z",
  "postingsLast30d": 6,
  "postingsPrev30d": 1,
  "velocity30d": 6,
  "sampleTitles": ["Strategic Account Executive", "Brand Designer", "Sr. Customer Experience Specialist", "Manager, Account Management", "Senior Product Marketing Manager, Enterprise"],
  "sourcesFound": ["greenhouse", "ashby"],
  "scrapedAt": "2026-08-23T23:59:16.557Z"
}

On a miss, signal mode still returns a row:

{ query, found: false, status: "NOT_FOUND", atsDetected: false, sourcesFound: [], scrapedAt }

Signal rows carry eleven more fields when Add hiring signals is on, which turn this mode from a snapshot into a week-over-week tracker. They are null otherwise, so the column set never changes with a checkbox. See Hiring signals for sales and investors.

Price

Job-list mode is composite billing: you pay one match event per platform that actually returns a board, up to $0.004 per platform matched (six platforms, so $0.024 is the worst case for a single company matched everywhere — realistically, most companies use exactly one of the six, if they use any of them at all). Signal mode bills differently: one flat Hiring signal event per company with a board anywhere, regardless of how many of the six platforms matched, at $0.008 per company. The two modes never bill together on the same run.

• Greenhouse match: $4 per 1,000 company slugs
• Lever match: $4 per 1,000 company slugs
• Ashby match: $4 per 1,000 company slugs
• Workable match: $4 per 1,000 company slugs
• SmartRecruiters match: $4 per 1,000 company slugs
• Personio match: $4 per 1,000 company slugs
• Hiring signal: $8 per 1,000 company slugs

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (found:false) are never charged.

1,000 companies through signal mode: ~$8 if every one has a board somewhere, less for the ones that don't. The same 1,000 rows through a credit-based enrichment platform: $80–$400. Job-list mode on the same 1,000 companies runs about ~$4 in the typical case of one platform matching per company, and up to ~$24 in the unrealistic worst case of every company matching on all six platforms. Both modes also discount on paid Apify tiers — down to $0.002 per platform match and $0.004 per signal-mode company on the Gold tier.

How to use

1. In the Apify Console. Open the actor page and click Start — the companySlugs field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. Via the API. Call it directly with a POST request — no Console needed once you have an API token:

   curl "https://api.apify.com/v2/acts/accountable_eel~ats-jobs-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"companySlugs":["stripe"]}'
   

3. On a schedule. Save this actor as an Apify Task with the input you want, then add a Schedule (hourly, daily, weekly) so it runs on its own — no server of your own required.

1. Pick a mode. Sourcing candidates or watching specific companies for new openings? Use the default jobs mode. Scoring or filtering an outbound list by hiring activity? Use "mode": "signal".
2. Paste in slugs. One company slug per line, or a full board URL from any of the six platforms — both work, and the same normalized slug is tried against all six either way.
3. In jobs mode, narrow results with includeKeywords/excludeKeywords if you only care about certain roles, and use columns to skip platforms you know your list won't hit (skip personio if your list is all US companies, for instance).
4. In signal mode, set hiringForGroups to your own segments if the five defaults (sales, engineering, marketing, customer-success, executive) don't match how you think about a target list.
5. Sanity-check first. Set testRun: true to run just the first 5 items before committing a full list.
6. Pull results from the dataset via the Apify API, or use the Overview / Hiring signals dataset views in Console, depending on which mode you ran.

Input

{
  "companySlugs": [
    "stripe"
  ]
}

One company slug per line (e.g. "stripe"), or paste a full board URL from any of the six platforms below — either works, and the same slug is tried against all six. Accepted formats: stripe, https://boards.greenhouse.io/stripe, https://jobs.lever.co/stripe.

companySlugs is the list of company slugs or ATS board URLs to look up — a bare slug like stripe, or a full URL like https://boards.greenhouse.io/stripe or https://jobs.lever.co/stripe, both work; the same normalized slug is tried against all six platforms regardless of which URL format you paste. mode picks the output shape: jobs (default) for the full postings list, or signal for one aggregated row per company. testRun limits a run to the first 5 items so you can sanity-check before scaling up. onlyFound hides rows where nothing matched (misses are always free either way). includeKeywords/excludeKeywords filter results by keyword, maxResults caps the run early, and columns lets you skip checking platforms you don't care about. maxConcurrency controls parallel item processing (default 5). hiringForGroups (signal mode only) customizes the job families the row reports hiring activity for.

Sample output

One row per company slug:

A slug that doesn't resolve on any of the six platforms comes back as found: false with a status of NOT_FOUND (or BAD_FORMAT/BLOCKED/ REQUEST_FAILED for other failure modes), no per-platform data, and is never charged. The dataset has two views: Overview (the job-list shape above) and Hiring signals (the one-row-per-company shape from mode: "signal").

Monitoring: only new results

Turn on Only return postings that are new since the last run and a company list becomes a hiring watchlist. Every posting is checked against the platform job IDs a previous run already delivered, and anything you have seen is dropped. A company whose board had nothing new comes back as a free NO_NEW_POSTINGS row and is not charged at all, so watching 500 companies on a quiet day costs only the run fee. Each run logs a line per company and platform, like stripe (greenhouse): 3 new of 148 fetched.

The first run has nothing to compare against, so it returns every open role and remembers it. From the second run on you get only the roles opened since.

To turn that into an alert:

1. Save your company list as a task with the checkbox on.
2. Add a Schedule to that task, daily is plenty for job boards.
3. Add a webhook on Run succeeded, pointing at Slack, n8n, Make or Zapier.

Memory lives in a named key-value store, ats-jobs-unified-lookup-delta, one record per company and platform, holding the last 5,000 postings each. Hiring-signal mode summarises a whole board rather than listing postings, so nothing is withheld there, but the same memory is what powers Add hiring signals, below.

Hiring signals for sales and investors

A job board tells you what a company has open. What a sales team or an investor actually wants is the derivative: what changed since last week, and in which direction. Turn on Add hiring signals alongside the monitoring checkbox, in Hiring signal mode, and every company row gains the run-over-run picture.

{
  "query": "ramp",
  "atsDetected": true,
  "atsPlatform": "ashby",
  "openRoles": 112,
  "signal": "gtm-push",
  "signalReason": "5 of the 8 new roles (63%) are sales or marketing, which usually means a go-to-market push rather than general growth.",
  "newRolesSinceLastRun": 8,
  "closedRolesSinceLastRun": 3,
  "growthPct": 4.7,
  "roleClusters": { "engineering": 41, "sales": 27, "marketing": 12, "ops": 19, "finance": 6, "other": 7 },
  "newRoleClusters": { "engineering": 2, "sales": 4, "marketing": 1, "ops": 1, "finance": 0, "other": 0 },
  "topDepartments": [{ "department": "Engineering", "count": 41 }, { "department": "Sales", "count": 27 }],
  "seniorityMix": { "junior": 6, "mid": 71, "senior": 24, "lead": 11 },
  "remoteShare": 0.38,
  "comparedToRunAt": "2026-09-03T06:00:00.000Z"
}

How the verdict is decided, in this order:

1. baseline if this is the first run of the watchlist. There is nothing to compare against yet, and calling every company on your list "expanding" on day one would put a false spike at the front of your time series.
2. expanding if growth is at least 20% or at least 5 roles opened, and the board is no smaller than it was.
3. gtm-push if sales plus marketing account for 40% or more of the newly opened roles.
4. contracting if more roles closed than opened.
5. steady otherwise.

The schedule recipe

1. Put 5 to 15 competitors or target accounts in Company slugs.
2. Set What do you need back? to Hiring signal.
3. Turn on Only return postings that are new since the last run, and Add hiring signals.
4. Give the watchlist a name in Watchlist name, for example competitors-weekly, so it stays separate from your other schedules.
5. Save it as a task, add a Schedule on it, and pick weekly. Weekly is the right cadence here: daily makes almost every row steady, because most boards do not move in a day.
6. Add a webhook on Run succeeded to push the dataset into Slack, Sheets, n8n or your CRM. The Hiring trends dataset view is already trimmed to the change columns for exactly this.

Your first scheduled run is the baseline. Read from run two on.

{
  "companySlugs": ["ramp", "brex", "mercury", "navan", "airbase"],
  "mode": "signal",
  "deltaMode": true,
  "signals": true,
  "deltaName": "competitors-weekly"
}

vs. TheirStack and PredictLeads

TheirStack and PredictLeads both sell hiring signals as a data product. TheirStack lists at roughly $0.005 to $0.03 per company; PredictLeads is sold as an annual contract, around $24,000 a year at the tiers most teams land on. Both are genuinely broader than this actor: they cover far more than six ATS platforms, they keep years of history, and they resolve a company from a domain rather than a board slug. If you need coverage of the whole market with back history, buy one of them.

What this gives you instead is the same weekly question answered at $0.008 per company found, off each company's own ATS API, with no contract, no minimum, and nothing charged for a company you do not find. For a watchlist of 15 competitors run weekly that is about $6 a year in signal charges. The trade-offs are real and worth naming: history starts the day you start running it rather than years ago, closedRolesSinceLastRun says a role left the board without saying whether it was filled or cancelled, and a company on Workday or an in-house ATS will not be found at all.

Two limits worth knowing

• SmartRecruiters pages at 100 postings but reports the true board size separately. On a SmartRecruiters company larger than that, openRoles and growthPct describe the whole board while newRolesSinceLastRun and closedRolesSinceLastRun are measured over the first page.
• The first run after a watchlist changes shape reports newRolesSinceLastRun and closedRolesSinceLastRun as null rather than guessing. That happens when individual postings cannot be matched against the stored run, and signalReason says so. openRoles, growthPct and all the level fields are unaffected.
• A plain "Manager" counts as mid in seniorityMix, not as lead. The word means a people leader about half the time and an individual contributor the rest ("Product Manager", "Account Manager"), so scoring it as leadership would make the mix unreadable. Titles saying Senior, Lead, Head, Principal, Staff, Director or above are counted as senior or lead as you would expect.

Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

curl "https://api.apify.com/v2/acts/accountable_eel~ats-jobs-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"companySlugs":["stripe"]}'

n8n. Add an HTTP Request node: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~ats-jobs-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body Content Type JSON, JSON Body {"companySlugs":["stripe"]} (swap in an expression from an earlier node for a real value).

Clay. Add an "HTTP API" column: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~ats-jobs-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body {"companySlugs":["{{company slug}}"]}, mapping the row's company slug into the companySlugs array.

MCP. In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Unified ATS Job Board Scraper | Apify" — the agent will find and run this actor.

For signal mode specifically: add formula columns straight off the response — openRoles > 0 for "is hiring", hiringFor.sales.hiring for "expanding the sales team", velocity30d >= 1.5 for "accelerating" — and let that drive which sequence a company enters, whether you're building the request in Clay, n8n, or an agent's tool call.

Tips

• Use signal mode for outbound prospecting or lead scoring — one row per company, with hiringFor booleans and velocity30d ready to drop straight into a Clay formula column or an n8n IF node.
• Use job-list mode when you need actual role details — sourcing candidates, watching specific openings, or feeding an apply-tracking sheet.
• Narrow columns to the platforms you know your market actually uses. It cuts both latency and the chance of an irrelevant platform ever billing — skip personio if your list is all US companies, for instance.
• Run signal mode on a weekly Apify schedule against a target-account list; velocity30d and postingsLast30d/postingsPrev30d flag companies that are accelerating hiring without you having to track history yourself.
• Replace the five default hiringForGroups with your own segments if your market doesn't map cleanly onto sales/engineering/marketing/customer-success/ executive.

vs. alternatives

Prices for third-party tools are their published list prices as of August 2026 and are not tracked here — check the vendor before relying on the comparison.

FAQ

What counts as "found", and what happens on a miss? At least one of the six platforms must return a non-empty postings list for the normalized slug. If none do, the row comes back found: false with a status explaining why (no match, bad input format, blocked request, or a failed request after retries) — and it's never billed, in either mode.

How does billing differ between job-list mode and signal mode? In jobs mode you pay one match event per platform that returned a board — a company on two platforms bills twice. In signal mode you pay exactly one Hiring signal event per company that had a board anywhere, no matter how many of the six platforms matched. The two never bill on the same run.

Why isn't Workday included among the six platforms? Workday has no vendor-wide API host — its endpoint URL embeds a tenant, a numbered pod (wd1–wd5), and a site name, none of which can be derived from a company slug alone. If you know a company uses Workday, use this portfolio's dedicated workday-jobs-lookup actor with the actual careers-site URL instead.

Are there rate limits, and can I control concurrency? maxConcurrency controls how many company slugs are processed in parallel (default 5). Each platform is queried through its own public posting API — the same endpoints each platform's own hosted careers page loads from — so a moderate concurrency setting avoids putting unusual load on any one of them.

How fresh is the data — is anything cached? Every run fetches live from each platform's API at request time; nothing is cached or stored between runs. scrapedAt on each row is the fetch timestamp, so you know exactly how current a row is.

Does this need a proxy or use Apify Proxy? No. All six platforms expose public, unauthenticated JSON or XML posting endpoints — the same ones each platform's own hosted careers page reads from — so there's no browser, no HTML scraping, and no proxy configuration to set up.

Is this safe to run under GDPR — does it collect personal data? It reads public job postings — title, department, location, apply link — not candidate or employee personal data. Nothing about individuals is collected or stored.

Can I schedule this to run automatically, or call it from an AI agent? Yes to both. Use Apify's built-in Schedule feature to run it on a recurring basis (weekly against a target-account list is a common pattern for signal mode), or call it synchronously over the API from a script, n8n, Make, or an MCP-enabled agent — see Use it from Clay, n8n, Make, or an AI agent above.

Related actors

• Greenhouse Jobs Lookup
• Lever Jobs Lookup
• Ashby Jobs Lookup