# Multi-ATS Jobs + Company Emails Scraper (`memo23/ats-jobs-scraper`) Actor

Turn job listings into a lead list. Scrape open roles from any company across 7 ATS platforms (Greenhouse, Lever, Ashby, SmartRecruiters, Workday, Personio, BambooHR) — auto-detected by URL or name — and enrich each with the hiring company contact email. One unified schema, full descriptions.

- **URL**: https://apify.com/memo23/ats-jobs-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Jobs, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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 Jobs + Company Emails Scraper 🧭✉️

Scrape **open jobs from any company across 10 major ATS platforms — Greenhouse, Lever, Ashby, SmartRecruiters, Workday, Workable, Recruitee, Breezy, Personio & BambooHR — and optionally attach the hiring company's contact email** for lead generation. Paste a board URL or just a company name; the ATS is auto-detected. One unified schema across every platform.

![How the Multi-ATS Jobs + Emails Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-ats-jobs.png)

---

### Why use this scraper

- **10 ATS platforms, one actor, one schema.** Greenhouse, Lever, Ashby, SmartRecruiters, Workday, Workable, Recruitee, Breezy, Personio, BambooHR — every job comes back in the same normalized shape, so you write one parser.
- **Auto-detects the ATS.** Don't know which ATS a company uses? Give the company name — the actor probes the supported platforms and picks the right one. Or paste any board URL and it routes by host.
- **Company contact email (lead-gen).** Flip on `enrichEmails` to turn a job feed into a sales/recruiting lead list — each company gets its `contactWebsite` plus a best-effort public `contactEmail` (e.g. a `careers@`/`info@` address) where one is published. A hiring-signal bonus, not a guaranteed per-row contact — coverage varies.
- **Full job detail.** Title, full description (HTML + text), compensation where shown, all locations, department, employment type, apply URL.
- **Built-in filters.** Title, location, department, remote, posted-after — applied before billing, so you only pay for matches.
- **Fast & cheap.** Public ATS APIs, no anti-bot, no browser.

---

### Supported ATS platforms

| ATS | Input example | Notes |
|---|---|---|
| **Greenhouse** | `https://boards.greenhouse.io/stripe` or `stripe` | Full content inline |
| **Lever** | `https://jobs.lever.co/spotify` or `spotify` | Full content inline |
| **Ashby** | `https://jobs.ashbyhq.com/ramp` or `ramp` | Full content inline |
| **SmartRecruiters** | `https://careers.smartrecruiters.com/BoschGroup` or `BoschGroup` | Company ID is case-sensitive |
| **Workday** | `https://{tenant}.wd5.myworkdayjobs.com/{Site}` | URL only (needs tenant + site) |
| **Personio** | `https://vodeno.jobs.personio.com` or `vodeno` | Public XML feed |
| **BambooHR** | `https://soundstripe.bamboohr.com` or `soundstripe` | Careers API |
| **Workable** | `https://apply.workable.com/pearltalent` or `pearltalent` | Detail fetched per job |
| **Recruitee** | `https://{company}.recruitee.com` or `{company}` | Full content inline |
| **Breezy** | `https://{company}.breezy.hr` or `{company}` | Description from posting page |

Mix any of these — URLs and bare names — in a single run.

---

### Use cases

- **Sales & recruiting lead-gen** — companies that are hiring are buying signals; pair each role with the company's contact email for targeted outreach.
- **Job boards & aggregators** — ingest fresh, structured roles from hundreds of companies across every major ATS in one pass.
- **Talent & market intelligence** — hiring velocity, remote-vs-onsite mix, departments, and pay bands across a company portfolio.
- **CRM enrichment** — append live hiring activity + a contact to your account list.

---

### How it works

1. **Resolve** each input — a URL routes to its ATS by host; a bare company name is **auto-detected** by probing the supported platforms in order.
2. **Fetch** that company's jobs from the ATS's public API (one call for inline ATSs; list + per-job detail for SmartRecruiters/BambooHR).
3. **Normalize** every job to one common schema.
4. **Enrich** (optional) — discover the company website and attach a contact email.
5. **Push** one row per job.

---

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | – | ATS board/job URLs (any of the 10 platforms). |
| `organizations` | array | – | Bare company names/slugs — ATS auto-detected. |
| `inputUrl` | string | – | URL to an `.xlsx` / `.csv` / Google Sheet of career links or company names — parsed and merged with the lists. |
| `enrichEmails` | boolean | `false` | Attach company `contactEmail` + `contactWebsite` (lead-gen). |
| `maxItems` | integer | `5000` | Max jobs per URL / company (free runs limited to 100 total). |
| `maxConcurrency` | integer | `10` | Companies processed in parallel. |
| `titleKeyword` / `location` / `department` | string | – | Client-side filters (contains). |
| `remoteOnly` | boolean | `false` | Keep only remote jobs. |
| `postedAfter` | string | – | Keep jobs published on/after YYYY-MM-DD. |
| `includeDescription` | boolean | `true` | Off = leaner rows (and skips detail fetch for SmartRecruiters/BambooHR). |
| `includeRawJson` | boolean | `false` | Attach the raw ATS payload. |
| `proxy` | object | – | Optional; not required (no anti-bot). |

#### Example input

```json
{
  "organizations": ["stripe", "ramp", "vodeno"],
  "startUrls": ["https://jobs.lever.co/spotify"],
  "enrichEmails": true,
  "maxItems": 1000,
  "titleKeyword": "engineer"
}
````

***

### Output

One row per job (normalized across all ATSs). With `enrichEmails`, the contact fields are added:

```json
{
  "ats": "greenhouse",
  "org": "stripe",
  "company": "Stripe",
  "globalId": "greenhouse:stripe:7954688",
  "title": "Backend Engineer",
  "department": "Engineering",
  "workplaceType": "Hybrid",
  "isRemote": false,
  "location": "San Francisco, CA",
  "locations": ["San Francisco, CA"],
  "descriptionHtml": "<p>…</p>",
  "descriptionText": "…",
  "publishedAt": "2026-06-19T12:11:02-04:00",
  "jobUrl": "https://stripe.com/jobs/search?gh_jid=7954688",
  "applyUrl": "https://stripe.com/jobs/search?gh_jid=7954688",
  "contactEmail": "careers@stripe.com",
  "contactWebsite": "stripe.com",
  "emailEnrichment": { "website": "stripe.com", "emails": ["careers@stripe.com"] },
  "scrapedAt": "2026-06-20T00:00:00.000Z"
}
```

#### Key output fields

| Field | Description |
|---|---|
| `ats` | Source platform (`greenhouse`/`lever`/`ashby`/`smartrecruiters`/`workday`/`workable`/`recruitee`/`breezy`/`personio`/`bamboohr`). |
| `company` | Hiring company name. |
| `globalId` | Stable `ats:org:jobId` key for cross-run dedup. |
| `title` / `department` / `employmentType` / `workplaceType` / `isRemote` | Core job fields. |
| `location` / `locations` | Primary + all locations. |
| `descriptionHtml` / `descriptionText` | Full description, HTML + plain text. |
| `publishedAt` / `jobUrl` / `applyUrl` | Date + links. |
| `contactEmail` / `contactWebsite` / `emailEnrichment` | Present when `enrichEmails` is on (lead-gen). |

***

### FAQ

**How does auto-detect work?** For a bare company name, the actor tries each supported ATS in order and uses the first that returns jobs. For a URL, it routes by hostname. SmartRecruiters company IDs are case-sensitive — pass the exact ID or a careers URL.

**Do I need a proxy?** No — these ATS APIs are public with no anti-bot.

**How accurate is the contact email?** Best-effort. It discovers the company website and harvests publicly published addresses (typically general inboxes like `careers@` / `info@`); many companies publish none, so coverage varies. Off by default since it adds time/cost.

**Can it scrape every company on an ATS?** No — ATSs have no public directory of all boards. You supply the companies.

***

### ⚠️ Disclaimer

This actor collects only **publicly available** job-posting data exposed by each ATS's own public API, plus publicly available company contact details. It does not access private/authenticated data or bypass access controls. You are responsible for using the data in compliance with each platform's terms and applicable laws (GDPR/CCPA included), especially when using contact data for outreach.

***

### SEO Keywords

multi-ATS scraper, ATS jobs scraper, Greenhouse Lever Ashby scraper, SmartRecruiters Personio BambooHR scraper, career page scraper, company jobs API, hiring signal scraper, lead generation jobs, recruiting leads, contact email enrichment, jobs plus company email, ATS job listing API, applicant tracking system scraper, careers page jobs, hiring intent data.

# Actor input Schema

## `startUrls` (type: `array`):

Any supported ATS board or job URL — Greenhouse (boards.greenhouse.io/{org}), Lever (jobs.lever.co/{org}), Ashby (jobs.ashbyhq.com/{org}), SmartRecruiters (careers.smartrecruiters.com/{Id}), Workday ({tenant}.wdN.myworkdayjobs.com/{Site}), Workable (apply.workable.com/{slug}), Recruitee ({slug}.recruitee.com), Breezy ({slug}.breezy.hr), Personio ({co}.jobs.personio.com), BambooHR ({co}.bamboohr.com). The ATS is detected from the URL host.

## `organizations` (type: `array`):

Bare company names/slugs, e.g. \["stripe", "notion", "ramp"]. For each, the actor probes the supported ATSs and uses the one that hosts that company. (SmartRecruiters company IDs are case-sensitive — pass the exact ID or a careers URL.)

## `inputUrl` (type: `string`):

Optional. A public URL to an .xlsx, .csv, or Google Sheet whose cells hold ATS board URLs and/or company names. Every URL or slug found is scraped (ATS auto-detected). For Google Sheets, share as 'Anyone with the link'.

## `enrichEmails` (type: `boolean`):

When enabled, each company is enriched with a contact email by discovering its website (Clearbit) and harvesting contact details — adds `contactEmail`, `contactWebsite`, and a detailed `emailEnrichment` object to every row. Best-effort. Adds time/cost per company, so it's off by default.

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

Hard cap on job rows emitted across the whole run (all companies combined). Use it to control billing — large boards have 500+ open roles.

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

How many companies to process in parallel.

## `titleKeyword` (type: `string`):

Keep only jobs whose title contains this text (case-insensitive), e.g. "engineer".

## `location` (type: `string`):

Keep only jobs whose location contains this text, e.g. "remote", "London", "New York".

## `department` (type: `string`):

Keep only jobs whose department contains this text, e.g. "Engineering".

## `employmentType` (type: `string`):

Keep only jobs whose employment type contains this text. Use a short stem that works across all ATSs, e.g. "full", "part", "contract", "intern".

## `remoteOnly` (type: `boolean`):

Keep only jobs flagged remote.

## `postedAfter` (type: `string`):

Keep only jobs published on or after this date (YYYY-MM-DD). Ideal for scheduled monitoring runs that only want fresh roles.

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

Include `descriptionHtml` and `descriptionText` on each row. Turn off for leaner, cheaper rows when you only need title/location/links. (For 2-call ATSs — SmartRecruiters, BambooHR — turning this off also skips the per-job detail fetch, making big runs much faster.)

## `includeRawJson` (type: `boolean`):

Attach the original, unmodified ATS job object to each row under a `raw` field. Off by default to keep rows lean.

## `proxy` (type: `object`):

Optional. These ATS APIs have no anti-bot, so a proxy is NOT required — use only for IP rotation at very large scale.

## Actor input object example

```json
{
  "startUrls": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/ramp",
    "https://careers.smartrecruiters.com/BoschGroup",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://vodeno.jobs.personio.com",
    "https://soundstripe.bamboohr.com"
  ],
  "organizations": [
    "notion",
    "figma"
  ],
  "enrichEmails": false,
  "maxItems": 5000,
  "maxConcurrency": 10,
  "remoteOnly": false,
  "includeDescription": true,
  "includeRawJson": false
}
```

# 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 = {
    "startUrls": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/ramp",
        "https://careers.smartrecruiters.com/BoschGroup",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "https://vodeno.jobs.personio.com",
        "https://soundstripe.bamboohr.com"
    ],
    "organizations": [
        "notion",
        "figma"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/ats-jobs-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 = {
    "startUrls": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.lever.co/spotify",
        "https://jobs.ashbyhq.com/ramp",
        "https://careers.smartrecruiters.com/BoschGroup",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "https://vodeno.jobs.personio.com",
        "https://soundstripe.bamboohr.com",
    ],
    "organizations": [
        "notion",
        "figma",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/ats-jobs-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 '{
  "startUrls": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.lever.co/spotify",
    "https://jobs.ashbyhq.com/ramp",
    "https://careers.smartrecruiters.com/BoschGroup",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://vodeno.jobs.personio.com",
    "https://soundstripe.bamboohr.com"
  ],
  "organizations": [
    "notion",
    "figma"
  ]
}' |
apify call memo23/ats-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-ATS Jobs + Company Emails Scraper",
        "description": "Turn job listings into a lead list. Scrape open roles from any company across 7 ATS platforms (Greenhouse, Lever, Ashby, SmartRecruiters, Workday, Personio, BambooHR) — auto-detected by URL or name — and enrich each with the hiring company contact email. One unified schema, full descriptions.",
        "version": "0.0",
        "x-build-id": "3pdVwDPLo5Plfl3hx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~ats-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-ats-jobs-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/memo23~ats-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-ats-jobs-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/memo23~ats-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-ats-jobs-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": {
                    "startUrls": {
                        "title": "ATS board / job URLs",
                        "type": "array",
                        "description": "Any supported ATS board or job URL — Greenhouse (boards.greenhouse.io/{org}), Lever (jobs.lever.co/{org}), Ashby (jobs.ashbyhq.com/{org}), SmartRecruiters (careers.smartrecruiters.com/{Id}), Workday ({tenant}.wdN.myworkdayjobs.com/{Site}), Workable (apply.workable.com/{slug}), Recruitee ({slug}.recruitee.com), Breezy ({slug}.breezy.hr), Personio ({co}.jobs.personio.com), BambooHR ({co}.bamboohr.com). The ATS is detected from the URL host.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organizations": {
                        "title": "Companies (name or slug — ATS auto-detected)",
                        "type": "array",
                        "description": "Bare company names/slugs, e.g. [\"stripe\", \"notion\", \"ramp\"]. For each, the actor probes the supported ATSs and uses the one that hosts that company. (SmartRecruiters company IDs are case-sensitive — pass the exact ID or a careers URL.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "inputUrl": {
                        "title": "Excel / CSV / Google Sheet URL (career links)",
                        "type": "string",
                        "description": "Optional. A public URL to an .xlsx, .csv, or Google Sheet whose cells hold ATS board URLs and/or company names. Every URL or slug found is scraped (ATS auto-detected). For Google Sheets, share as 'Anyone with the link'."
                    },
                    "enrichEmails": {
                        "title": "Enrich with company contact email",
                        "type": "boolean",
                        "description": "When enabled, each company is enriched with a contact email by discovering its website (Clearbit) and harvesting contact details — adds `contactEmail`, `contactWebsite`, and a detailed `emailEnrichment` object to every row. Best-effort. Adds time/cost per company, so it's off by default.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum jobs to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on job rows emitted across the whole run (all companies combined). Use it to control billing — large boards have 500+ open roles.",
                        "default": 5000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many companies to process in parallel.",
                        "default": 10
                    },
                    "titleKeyword": {
                        "title": "Title contains",
                        "type": "string",
                        "description": "Keep only jobs whose title contains this text (case-insensitive), e.g. \"engineer\"."
                    },
                    "location": {
                        "title": "Location contains",
                        "type": "string",
                        "description": "Keep only jobs whose location contains this text, e.g. \"remote\", \"London\", \"New York\"."
                    },
                    "department": {
                        "title": "Department contains",
                        "type": "string",
                        "description": "Keep only jobs whose department contains this text, e.g. \"Engineering\"."
                    },
                    "employmentType": {
                        "title": "Employment type contains",
                        "type": "string",
                        "description": "Keep only jobs whose employment type contains this text. Use a short stem that works across all ATSs, e.g. \"full\", \"part\", \"contract\", \"intern\"."
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Keep only jobs flagged remote.",
                        "default": false
                    },
                    "postedAfter": {
                        "title": "Posted on/after",
                        "type": "string",
                        "description": "Keep only jobs published on or after this date (YYYY-MM-DD). Ideal for scheduled monitoring runs that only want fresh roles."
                    },
                    "includeDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "Include `descriptionHtml` and `descriptionText` on each row. Turn off for leaner, cheaper rows when you only need title/location/links. (For 2-call ATSs — SmartRecruiters, BambooHR — turning this off also skips the per-job detail fetch, making big runs much faster.)",
                        "default": true
                    },
                    "includeRawJson": {
                        "title": "Include raw ATS payload",
                        "type": "boolean",
                        "description": "Attach the original, unmodified ATS job object to each row under a `raw` field. Off by default to keep rows lean.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. These ATS APIs have no anti-bot, so a proxy is NOT required — use only for IP rotation at very large scale."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
