# 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, MCP servers
- **Stats:** 60 total users, 10 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.66 / 1,000 job scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

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

> **Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Greenhouse, Lever, Ashby, SmartRecruiters and Workday, or any of their owners or subsidiaries. All trademarks mentioned are the property of their respective owners. Site names are referenced only to describe the publicly available sources this Actor collects data from.

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.

### How much does it cost?

This Actor uses Apify's **pay-per-event** pricing: you are charged only for the results it delivers, with no monthly rental and no start fee. The events it can charge are:

- **Job Scraped** - One fully-enriched job posting: title, company, location/geo, department, employment type, salary/equity (when published), apply link, and full description (HTML + plain text). Works across Greenhouse, Lever, Ashby, SmartRecruiters and Workday.

The current price of each event is shown on the **Pricing** tab of this page. Set a maximum total charge on the run if you want a hard cap on spend, and use the input limits to control how much the Actor fetches.

### 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.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### 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.

### Disclaimer

**This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Greenhouse, Lever, Ashby, SmartRecruiters and Workday, or any of their owners or subsidiaries. All trademarks mentioned are the property of their respective owners.**

Site and brand names are referenced only in a descriptive, nominative sense - to identify the publicly accessible sources this Actor collects data from. It is not an official product of any of them, is not authorised or certified by them, and does not distribute their software. It collects only publicly available information; you are responsible for ensuring your use of that data complies with applicable laws, regulations and the terms of each source.

### 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.

## `urlsFromFile` (type: `string`):

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## 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
    },
    "urlsFromFile": ""
};

// 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 },
    "urlsFromFile": "",
}

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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
  },
  "urlsFromFile": ""
}' |
apify call scrapesage/multi-ats-job-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapesage/multi-ats-job-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rfxsTS072laE2duIK/builds/5wJubkJRMI0kL6HGi/openapi.json