ATS Jobs Unified Lookup — 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 }

Price

Job-list mode is composite billing: you pay one match event per platform that actually returns a board, up to $0.005 per platform matched (six platforms, so $0.03 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: $5 per 1,000 company slugs
• Lever match: $5 per 1,000 company slugs
• Ashby match: $5 per 1,000 company slugs
• Workable match: $5 per 1,000 company slugs
• SmartRecruiters match: $5 per 1,000 company slugs
• Personio match: $5 per 1,000 company slugs
• Hiring signal: $8 per 1,000 company slugs

Plus a $0.005 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 ~$5 in the typical case of one platform matching per company, and up to ~$30 in the unrealistic worst case of every company matching on all six platforms. Both modes also discount on paid Apify tiers — down to $0.0038 per platform match and $0.00608 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").

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 API | 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