# Multi-ATS Job Scraper — Greenhouse, Lever, Ashby, Workday (`scrapesage/multi-ats-job-scraper`) Actor

Scrape jobs from the 5 biggest ATS platforms in one dataset — Greenhouse, Lever, Ashby, SmartRecruiters & Workday. Full descriptions, salaries, locations, departments & apply links. Auto-detects the ATS from a careers URL or company name. Monitor mode emits only new jobs.

- **URL**: https://apify.com/scrapesage/multi-ats-job-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 job scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Multi-ATS Job Scraper — Greenhouse, Lever, Ashby, SmartRecruiters & Workday

Scrape **job postings from the 5 biggest applicant tracking systems (ATS) in one run** — **Greenhouse, Lever, Ashby, SmartRecruiters, and Workday** — into a single, unified, richly-structured dataset. Paste a careers URL or just a company name and the actor **auto-detects the ATS**, pulls every public posting, and normalizes it: **full job descriptions, salary ranges, locations & geo, departments, employment type, and direct apply links** — the same column layout no matter which ATS the job came from.

No login, no cookies, no browser — fast, direct API extraction straight from each company's own career board, with **monitor mode** to capture only newly-posted jobs on a schedule.

### Why this job scraper?

Most job scrapers cover one ATS, or one job aggregator that's hours-to-days stale and strips the fields that matter. This actor reads **each company's live career board directly** — so the data is as fresh as the company's own careers page — and merges five different ATS formats into **one clean schema**. It ships the **richest job dataset in the category**:

| Data | Single-ATS / aggregator scrapers | This actor |
|---|---|---|
| Greenhouse + Lever + Ashby + SmartRecruiters + Workday | ❌ one at a time | ✅ all five, one dataset |
| Auto-detect ATS from a company name or URL | ❌ | ✅ |
| Full job description (HTML **and** plain text) | partial | ✅ |
| Salary range + currency + equity flag | ❌ usually null | ✅ when published |
| City / region / country + lat-long geo | partial | ✅ |
| Department, team, employment type, experience level | ❌ | ✅ |
| Direct apply URL + canonical job URL | partial | ✅ |
| Requisition ID, posted/updated dates | ❌ | ✅ |
| Employer custom fields (division, brand, contract…) | ❌ | ✅ (SmartRecruiters) |
| Unified columns across every ATS | ❌ | ✅ |
| Monitor mode — only new postings | ❌ | ✅ |

### Use cases

- **Recruiting & sourcing intelligence** — track who's hiring, for what, and where, across hundreds of companies' real career boards in one feed.
- **Sales & lead generation** — a new job posting is a **buying signal**. Monitor target accounts for roles that signal budget, expansion, or a new initiative (e.g. "Head of RevOps", "first Data Engineer"), and reach out the day it appears.
- **Job boards & aggregators** — power a niche job site with fresh, structured, deduplicated postings — including descriptions and salaries — without scraping each ATS yourself.
- **Labor-market & compensation research** — analyze salary ranges, remote/hybrid mix, and hiring velocity by company, department, and location.
- **Competitive monitoring** — watch competitors' headcount plans: which teams are growing, which markets they're entering, how fast they post.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Multi-ATS Job Scraper**, add companies (a careers URL, an `ats:token` shorthand, or a plain company name), and click **Start**.
3. Watch results stream into the dataset table — one clean row per job, same columns for every ATS.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "companies": [
        "https://boards.greenhouse.io/figma",
        "lever:palantir",
        "ashby:openai",
        "https://careers.smartrecruiters.com/BoschGroup",
        "https://salesforce.wd12.myworkdayjobs.com/External_Career_Site"
    ],
    "searchTerms": ["engineer", "data"],
    "locationFilters": ["remote", "london"],
    "includeDescription": true,
    "includeCompensation": true,
    "maxItemsPerCompany": 200,
    "onlyNewItems": false
}
````

- **companies** — one entry per company. Each can be:
  - **a careers/board URL** (most reliable): `https://boards.greenhouse.io/figma`, `https://jobs.lever.co/palantir`, `https://jobs.ashbyhq.com/openai`, `https://careers.smartrecruiters.com/BoschGroup`, `https://salesforce.wd12.myworkdayjobs.com/External_Career_Site`;
  - **an `ats:token` shorthand**: `greenhouse:figma`, `lever:palantir`, `ashby:openai`, `smartrecruiters:BoschGroup`;
  - **a plain company name** to auto-detect across Greenhouse, Lever, Ashby and SmartRecruiters. **Workday always needs a URL** (its address encodes the data-center and career-site, which can't be guessed from a name).
- **searchTerms** — optional keyword filter; a job is kept if any term appears in its title, department, tags, or description.
- **locationFilters** — optional location filter (`remote`, `london`, `united states`, …) matched against location, city, region, and country.
- **includeDescription** *(default true)* — full description (HTML + plain text). Free for Greenhouse/Lever/Ashby; adds one detail request per job for SmartRecruiters/Workday.
- **includeCompensation** *(default true)* — parse salary ranges and equity flags where published.
- **includeRawData** *(default false)* — attach the complete original ATS object under `raw`.
- **maxItemsPerCompany / maxItems** *(default 0 = no limit)* — caps for test runs or budget control.
- **onlyNewItems** *(default false)* — **monitor mode**: emit only postings not seen in previous runs (see below).
- **dedupStoreName** *(default `ats-jobs-state`)* — named store holding seen job IDs for monitor mode.
- **proxyConfiguration** — proxy settings (default Apify datacenter proxy; residential is **not** needed).

### Output

One clean record per job, **identical columns across every ATS**:

```json
{
    "ats": "greenhouse",
    "companyName": "Figma",
    "companySlug": "figma",
    "jobId": "5822886004",
    "title": "Staff Software Engineer, Platform",
    "url": "https://boards.greenhouse.io/figma/jobs/5822886004",
    "applyUrl": "https://boards.greenhouse.io/figma/jobs/5822886004",
    "descriptionHtml": "<div class=\"content-intro\"><p>Figma is growing…</p></div>",
    "descriptionText": "Figma is growing our team of passionate creatives and builders…",
    "department": "Engineering",
    "team": "Platform",
    "jobFunction": null,
    "employmentType": "Full-time",
    "experienceLevel": null,
    "location": "San Francisco, CA",
    "locations": ["San Francisco, CA", "New York, NY"],
    "isRemote": false,
    "workplaceType": "hybrid",
    "city": "San Francisco",
    "region": "CA",
    "country": "US",
    "postalCode": "94103",
    "latitude": 37.7765,
    "longitude": -122.3963,
    "salaryMin": 230000,
    "salaryMax": 310000,
    "salaryCurrency": "USD",
    "salaryInterval": "year",
    "salaryRaw": "$230K – $310K • Offers Equity",
    "hasEquity": true,
    "requisitionId": "2178",
    "postedAt": "2026-04-17T12:21:54.000Z",
    "updatedAt": "2026-04-17T16:25:57.000Z",
    "tags": ["Engineering"],
    "customFields": [{ "label": "Division", "value": "Product" }],
    "companyInput": "https://boards.greenhouse.io/figma",
    "scrapedAt": "2026-06-12T12:00:00.000Z"
}
```

#### What to expect (field coverage)

Different ATS platforms expose different fields, and many are populated only when the employer filled them in. Verified across all five platforms, you can typically expect:

| Field | Greenhouse | Lever | Ashby | SmartRecruiters | Workday |
|---|---|---|---|---|---|
| Title, URL, apply URL | ✅ | ✅ | ✅ | ✅ | ✅ |
| Full description | ✅ | ✅ | ✅ | ✅ (detail call) | ✅ (detail call) |
| Department / team | ✅ | ✅ | ✅ | ✅ | — |
| Location | ✅ | ✅ | ✅ | ✅ + lat-long | ✅ |
| Salary range | when set | when set | **often** | rarely | — |
| Requisition ID | ✅ | — | — | ✅ | ✅ |
| Posted / updated dates | ✅ | ✅ | ✅ | ✅ | ✅ |

A blank field means the employer didn't publish it for that posting — not that scraping failed. Nothing is dropped, so you always get the richest record available from each board.

### Monitor only new jobs

Turn on **`onlyNewItems`** and the actor saves every job ID it has seen in a **named key-value store** (`dedupStoreName`), then on each later run emits **only postings that weren't there before**. Combined with a daily [Schedule](https://docs.apify.com/platform/schedules), you get a clean feed of *just* the new roles at your target companies — perfect for hiring-signal alerts and job-board ingestion.

- The **first run emits everything** (and seeds the store); subsequent runs emit only the delta.
- Monitor mode is the actor's own dedupe layer — it **complements**, and does not conflict with, Apify [Schedules](https://docs.apify.com/platform/schedules) (a cron trigger) or the Console [Monitoring](https://docs.apify.com/platform/monitoring) tab (charts & alerts).
- Use a **distinct `dedupStoreName` per independent monitor** (e.g. per client or per company set) so their states don't mix.
- If you schedule frequent runs, enable the Schedule's *exclusive* option so a new run doesn't start before the previous one finishes writing its state.
- Heads-up: a quiet run legitimately returns **0 items**, which can trip a Console Monitoring "results lower than N" alert — expected behavior, not an error.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily/weekly to track new postings at your target companies; pair with `onlyNewItems` for a new-jobs-only feed.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, job-board ingest) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/multi-ats-job-scraper').call({
    companies: [
        'https://boards.greenhouse.io/figma',
        'lever:palantir',
        'ashby:openai',
    ],
    searchTerms: ['engineer'],
    onlyNewItems: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} new job postings`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new job postings straight into your ATS, CRM, or spreadsheet.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored company posts a new role.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find all remote data engineering roles at these ten companies and list salary and apply links" and let it run the scraper for you.

### More scrapers from scrapesage

Build a complete **hiring-intelligence & lead-gen stack**:

- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings from LinkedIn as hiring-intent signals.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events plus organizer leads (ticket prices, emails, socials).
- **[Sched Conference Scraper](https://apify.com/scrapesage/sched-conference-scraper)** — speakers, sessions, and sponsors from Sched conference sites.
- **[Whova Event Scraper](https://apify.com/scrapesage/whova-event-scraper)** — attendees, agendas, and sponsors from Whova event apps.
- **[Swapcard Exhibitor Scraper](https://apify.com/scrapesage/swapcard-exhibitor-scraper)** — exhibitor lists and contacts from Swapcard-powered events.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — competitor ad intelligence on Meta & Instagram.
- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — who's advertising what on Google.
- **[Airbnb Scraper](https://apify.com/scrapesage/airbnb-scraper)** — listings, prices, and availability.

### Tips

- **The careers URL is the most reliable input.** Plain company names are auto-detected by trying common slugs — great for Greenhouse/Lever/Ashby/SmartRecruiters, but if a name doesn't resolve, paste the board URL or use an `ats:token` shorthand. **Workday always needs the URL.**
- **Listing-only, faster runs**: set `includeDescription: false` to skip the per-job detail calls on SmartRecruiters and Workday (Greenhouse/Lever/Ashby always include descriptions for free).
- **Big boards**: use `maxItemsPerCompany` for quick tests; the actor paginates the whole board by default.
- **Salaries** are richest on Ashby, Lever, and Greenhouse — many US postings publish ranges and equity; SmartRecruiters/Workday rarely do.
- **Recurring monitoring**: combine `onlyNewItems` with [Schedules](https://docs.apify.com/platform/schedules) and a [webhook](https://docs.apify.com/platform/integrations/webhooks) to push new roles into your CRM the moment they appear.

### FAQ

**Which ATS platforms are supported?** Greenhouse, Lever, Ashby, SmartRecruiters, and Workday — the five most widely used by mid-market and enterprise employers. One run can mix all of them.

**How do I find a company's careers URL?** It's the page their "Apply" / "Open roles" links point to — e.g. `boards.greenhouse.io/<company>`, `jobs.lever.co/<company>`, `jobs.ashbyhq.com/<company>`, `careers.smartrecruiters.com/<Company>`, or `<company>.wdN.myworkdayjobs.com/<Site>`. Paste that, or just try the company name.

**Does it need an API key or login?** No. It reads each company's public career-board API — the same data their own careers page shows — no key, cookie, or login required.

**Why does a plain company name sometimes not resolve?** Auto-detection guesses the board token by trying common slug spellings. Unusual slugs (or any Workday tenant) can't be guessed — paste the careers URL or use `ats:token` and it works every time.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor companies for new jobs automatically?** Turn on `onlyNewItems`, create a [Schedule](https://docs.apify.com/platform/schedules) (e.g. daily), and optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push new postings into your CRM as they appear.

**A field is empty — why?** Different ATS platforms expose different fields, and many (salary, department, requisition ID) are filled in only when the employer chooses to. Empty means the employer didn't publish it — never that the scraper skipped it.

**Is scraping job boards legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and each site's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests — more ATS platforms, more fields — are welcome; this actor is actively maintained.

# Actor input Schema

## `companies` (type: `array`):

One entry per company. Each can be: <b>a careers/board URL</b> (most reliable) — e.g. <code>https://boards.greenhouse.io/figma</code>, <code>https://jobs.lever.co/palantir</code>, <code>https://jobs.ashbyhq.com/openai</code>, <code>https://careers.smartrecruiters.com/BoschGroup</code>, <code>https://salesforce.wd12.myworkdayjobs.com/External\_Career\_Site</code>; an <b>"ats:token" shorthand</b> — <code>greenhouse:figma</code>, <code>lever:palantir</code>, <code>ashby:openai</code>, <code>smartrecruiters:BoschGroup</code>; or a <b>plain company name</b> to auto-detect (Greenhouse, Lever, Ashby, SmartRecruiters). <b>Workday always needs a URL.</b>

## `searchTerms` (type: `array`):

Optional keywords. A job is kept if any term appears in its title, department, tags, or description (case-insensitive). Leave empty to return every posting.

## `locationFilters` (type: `array`):

Optional location keywords. A job is kept if any term appears in its location, city, region, or country (e.g. <code>London</code>, <code>Remote</code>, <code>United States</code>). Leave empty for all locations.

## `includeDescription` (type: `boolean`):

Fetch the full job description (HTML + plain text). Free for Greenhouse, Lever and Ashby (in the listing). For SmartRecruiters and Workday this adds one detail request per job — turn off for faster, cheaper listing-only runs.

## `includeCompensation` (type: `boolean`):

Parse salary ranges and equity flags where the employer publishes them (richest on Ashby, Lever and Greenhouse).

## `includeRawData` (type: `boolean`):

Attach the complete original ATS response object for each job under a <code>raw</code> field — useful when you need a field this actor doesn't map yet.

## `maxItemsPerCompany` (type: `integer`):

Cap the number of jobs scraped per company (0 = no limit). Handy for quick test runs on large boards.

## `maxItems` (type: `integer`):

Hard cap on total jobs across all companies (0 = no limit).

## `onlyNewItems` (type: `boolean`):

Emit only postings not seen in previous runs. Seen job IDs are saved in a named key-value store (below) and compared on every run, so a daily Schedule yields just the new jobs. The first run emits everything. Note: quiet runs return 0 items, which can trip a Console Monitoring "results lower than N" alert.

## `dedupStoreName` (type: `string`):

Name of the named key-value store that holds previously-seen job IDs for monitor mode. Use a different name per independent monitor (e.g. per client or per company set).

## `maxConcurrency` (type: `integer`):

Parallel detail requests (SmartRecruiters / Workday).

## `proxyConfiguration` (type: `object`):

Proxy settings. The ATS APIs accept direct requests, so the default Apify (datacenter) proxy is plenty — no residential proxy needed.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/figma",
    "lever:palantir"
  ],
  "searchTerms": [],
  "locationFilters": [],
  "includeDescription": true,
  "includeCompensation": true,
  "includeRawData": false,
  "maxItemsPerCompany": 0,
  "maxItems": 0,
  "onlyNewItems": false,
  "dedupStoreName": "ats-jobs-state",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped job postings as JSON items in the default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "https://boards.greenhouse.io/figma",
        "lever:palantir"
    ],
    "searchTerms": [],
    "locationFilters": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/multi-ats-job-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companies": [
        "https://boards.greenhouse.io/figma",
        "lever:palantir",
    ],
    "searchTerms": [],
    "locationFilters": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/multi-ats-job-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "https://boards.greenhouse.io/figma",
    "lever:palantir"
  ],
  "searchTerms": [],
  "locationFilters": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/multi-ats-job-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/multi-ats-job-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-ATS Job Scraper — Greenhouse, Lever, Ashby, Workday",
        "description": "Scrape jobs from the 5 biggest ATS platforms in one dataset — Greenhouse, Lever, Ashby, SmartRecruiters & Workday. Full descriptions, salaries, locations, departments & apply links. Auto-detects the ATS from a careers URL or company name. Monitor mode emits only new jobs.",
        "version": "1.0",
        "x-build-id": "bQEvnPz9ONsWhtB9w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~multi-ats-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-multi-ats-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesage~multi-ats-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-multi-ats-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesage~multi-ats-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-multi-ats-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companies": {
                        "title": "Companies / career boards",
                        "type": "array",
                        "description": "One entry per company. Each can be: <b>a careers/board URL</b> (most reliable) — e.g. <code>https://boards.greenhouse.io/figma</code>, <code>https://jobs.lever.co/palantir</code>, <code>https://jobs.ashbyhq.com/openai</code>, <code>https://careers.smartrecruiters.com/BoschGroup</code>, <code>https://salesforce.wd12.myworkdayjobs.com/External_Career_Site</code>; an <b>\"ats:token\" shorthand</b> — <code>greenhouse:figma</code>, <code>lever:palantir</code>, <code>ashby:openai</code>, <code>smartrecruiters:BoschGroup</code>; or a <b>plain company name</b> to auto-detect (Greenhouse, Lever, Ashby, SmartRecruiters). <b>Workday always needs a URL.</b>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms (keyword filter)",
                        "type": "array",
                        "description": "Optional keywords. A job is kept if any term appears in its title, department, tags, or description (case-insensitive). Leave empty to return every posting.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationFilters": {
                        "title": "Location filter",
                        "type": "array",
                        "description": "Optional location keywords. A job is kept if any term appears in its location, city, region, or country (e.g. <code>London</code>, <code>Remote</code>, <code>United States</code>). Leave empty for all locations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDescription": {
                        "title": "Include full job descriptions",
                        "type": "boolean",
                        "description": "Fetch the full job description (HTML + plain text). Free for Greenhouse, Lever and Ashby (in the listing). For SmartRecruiters and Workday this adds one detail request per job — turn off for faster, cheaper listing-only runs.",
                        "default": true
                    },
                    "includeCompensation": {
                        "title": "Include salary / compensation",
                        "type": "boolean",
                        "description": "Parse salary ranges and equity flags where the employer publishes them (richest on Ashby, Lever and Greenhouse).",
                        "default": true
                    },
                    "includeRawData": {
                        "title": "Include raw ATS object",
                        "type": "boolean",
                        "description": "Attach the complete original ATS response object for each job under a <code>raw</code> field — useful when you need a field this actor doesn't map yet.",
                        "default": false
                    },
                    "maxItemsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of jobs scraped per company (0 = no limit). Handy for quick test runs on large boards.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max jobs (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total jobs across all companies (0 = no limit).",
                        "default": 0
                    },
                    "onlyNewItems": {
                        "title": "Monitor mode — only new jobs",
                        "type": "boolean",
                        "description": "Emit only postings not seen in previous runs. Seen job IDs are saved in a named key-value store (below) and compared on every run, so a daily Schedule yields just the new jobs. The first run emits everything. Note: quiet runs return 0 items, which can trip a Console Monitoring \"results lower than N\" alert.",
                        "default": false
                    },
                    "dedupStoreName": {
                        "title": "Monitor state store name",
                        "type": "string",
                        "description": "Name of the named key-value store that holds previously-seen job IDs for monitor mode. Use a different name per independent monitor (e.g. per client or per company set).",
                        "default": "ats-jobs-state"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Parallel detail requests (SmartRecruiters / Workday).",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The ATS APIs accept direct requests, so the default Apify (datacenter) proxy is plenty — no residential proxy needed.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```