# Multi-ATS Hiring Intent Monitor (`scraping_scrap/multi-ats-hiring-intent-monitor`) Actor

Monitor public career pages and ATS job boards across Greenhouse, Lever, Ashby, SmartRecruiters, Workday, and generic career pages. Detect new, changed, and removed jobs, generate hiring intent signals, and export normalized job records with company summaries.

- **URL**: https://apify.com/scraping\_scrap/multi-ats-hiring-intent-monitor.md
- **Developed by:** [Вадим Захаров](https://apify.com/scraping_scrap) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Hiring Intent Monitor

Monitor public company career pages and ATS boards for new, changed, and removed jobs. Extract normalized job records, detect hiring intent signals, create company summaries, and track changes over time.

This Actor works as a Greenhouse jobs scraper, Lever jobs scraper, Ashby jobs scraper, SmartRecruiters jobs scraper, Workday jobs scraper, ATS jobs scraper, career page scraper, hiring intent monitor, and job change monitor for public hiring data.

It is built for recruiting intelligence, sales intelligence, account monitoring, market research, and company hiring signals.

### What this Actor does

- Accepts company domains and direct career URLs.
- Discovers public career pages from company domains.
- Detects supported ATS platforms automatically.
- Extracts public job postings from supported ATS sources.
- Normalizes titles, locations, departments, descriptions, seniority, remote type, skills, and compensation fields.
- Tracks `new`, `changed`, `unchanged`, and `removed` jobs across recurring runs.
- Emits optional `company_summary` records with hiring signals.
- Saves a user-facing run summary in key-value store record `OUTPUT`.

The Actor uses public career pages and public ATS endpoints only. It does not use LinkedIn, private ATS APIs, login-only systems, cookies, candidate systems, or hidden/private endpoints.

### Supported ATS sources

| Source | Behavior |
| --- | --- |
| Greenhouse | Uses public Greenhouse job board APIs where available. |
| Lever | Uses public Lever postings APIs, including EU host detection. |
| Ashby | Uses public Ashby posting APIs and requests compensation when available. |
| SmartRecruiters | Uses public SmartRecruiters company postings pagination. |
| Workday | Best-effort extraction from public visible HTML and JSON-LD. |
| Generic career pages | Best-effort JSON-LD and visible job-link extraction. |

Supported platform input values:

```json
["auto", "greenhouse", "lever", "ashby", "workday", "smartrecruiters", "generic"]
````

Use `auto` for normal runs.

### What data you get

The default dataset contains `job` records and, when enabled, `company_summary` records.

Job records include:

- company and source metadata
- ATS platform and ATS job ID
- stable job identity fields
- `fingerprint` and `contentHash`
- title and normalized title
- location and normalized location
- department, team, and employment type
- remote type
- seniority
- extracted skills
- matched keywords and locations
- text description
- optional HTML description
- salary and compensation fields
- posting and apply URLs
- change status
- first seen, last seen, removed timestamps
- warnings and errors arrays

Compensation fields are always present and nullable:

```text
salaryMin
salaryMax
salaryCurrency
salaryPeriod
compensationText
```

`descriptionText` is always present on job records and is `""` when an ATS listing does not expose description text. `descriptionHtml` is emitted only when `includeDescriptionHtml` is `true`. `rawSource` is emitted only when `includeRawSource` is `true`.

After a normal run, the Actor also writes a KVS `OUTPUT` record in the run's default key-value store. `OUTPUT` is a user-facing run summary, not persistent state.

`OUTPUT` includes:

- `actorName`
- `runId`
- `scrapedAt`
- `datasetId`
- `keyValueStoreId`
- `stateKey`
- `summary`
- `byAtsPlatform`
- `byCompany`
- `topHiringSignals`
- `warnings`
- `errors`

The `summary` counters include discovered targets, detected targets, successful and failed targets, parser success/failure by ATS, zero-job boards, blocked updates, updated/preserved state counts, emitted records, and job status totals.

### Input examples

#### Company domain baseline

Use this for the first run of a monitor.

```json
{
  "companyDomains": ["example.com", "acme.com"],
  "atsPlatforms": ["auto"],
  "onlyChangesSinceLastRun": false,
  "stateKey": "baseline-monitor",
  "includeCompanySummary": true,
  "maxJobsPerCompany": 500
}
```

#### Scheduled delta run

Use the same `stateKey` for recurring monitoring.

```json
{
  "companyDomains": ["example.com", "acme.com"],
  "atsPlatforms": ["auto"],
  "onlyChangesSinceLastRun": true,
  "stateKey": "baseline-monitor",
  "includeCompanySummary": true,
  "maxJobsPerCompany": 500
}
```

#### Direct career URLs

Use direct URLs when you already know the ATS board or career page.

```json
{
  "careerUrls": [
    "https://boards.greenhouse.io/acme",
    "https://jobs.lever.co/example",
    "https://jobs.ashbyhq.com/example",
    "https://careers.smartrecruiters.com/example"
  ],
  "atsPlatforms": ["auto"],
  "stateKey": "direct-boards-monitor",
  "includeCompanySummary": true
}
```

#### Keyword and location matching

Keywords and locations enrich output. They do not filter jobs out.

```json
{
  "companyDomains": ["example.com"],
  "keywords": ["AI", "LLM", "RevOps", "security"],
  "locations": ["London", "Berlin", "Remote"],
  "stateKey": "keyword-location-monitor",
  "includeCompanySummary": true
}
```

`proxyConfiguration` can be provided when you want Apify Proxy settings for HTTP requests.

#### Debug output

Use only when inspecting parser behavior.

```json
{
  "careerUrls": ["https://boards.greenhouse.io/example"],
  "includeRawSource": true,
  "includeDescriptionHtml": true,
  "stateKey": "debug-monitor"
}
```

### Output examples

#### Job record

```json
{
  "recordType": "job",
  "runId": "abc123",
  "scrapedAt": "2026-06-06T10:00:00.000Z",
  "companyDomain": "example.com",
  "companyName": "Example",
  "sourceUrl": "https://boards.greenhouse.io/example",
  "careerUrl": "https://boards.greenhouse.io/example",
  "atsPlatform": "greenhouse",
  "atsJobId": "job-2",
  "stableJobKey": "example.com|greenhouse|job-2",
  "fingerprint": "0adcd377d1d9b02d5ba4a6ea09cc2dcfe2e2c0f169e0d4c132e750894f0cb71c",
  "contentHash": "3bf383d76d0d8b659100d07983e99b9debf179791994401e63d47d6462179c6e",
  "title": "LLM Engineer",
  "normalizedTitle": "llm engineer",
  "location": "London",
  "normalizedLocation": "london",
  "department": "AI",
  "team": "AI",
  "remoteType": "onsite",
  "seniority": "unknown",
  "skills": ["AI", "LLM"],
  "matchedKeywords": ["LLM"],
  "matchedLocations": ["London"],
  "descriptionText": "Build LLM systems in London.",
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "salaryPeriod": null,
  "compensationText": null,
  "postingUrl": "https://boards.greenhouse.io/example/jobs/job-2",
  "applyUrl": null,
  "changeStatus": "new",
  "firstSeenAt": "2026-06-06T10:00:00.000Z",
  "lastSeenAt": "2026-06-06T10:00:00.000Z",
  "removedAt": null,
  "isCurrent": true,
  "warnings": [],
  "errors": []
}
```

#### Company summary

```json
{
  "recordType": "company_summary",
  "runId": "abc123",
  "scrapedAt": "2026-06-06T10:00:00.000Z",
  "companyDomain": "example.com",
  "companyName": "Example",
  "processedSourceUrls": ["https://boards.greenhouse.io/example"],
  "atsPlatformsDetected": ["greenhouse"],
  "totalCurrentJobs": 25,
  "emittedJobRecords": 3,
  "newJobs": 2,
  "changedJobs": 1,
  "removedJobs": 0,
  "unchangedJobs": 22,
  "topDepartments": [{ "name": "Engineering", "count": 12 }],
  "topLocations": [{ "name": "London", "count": 5 }],
  "newLocations": ["London"],
  "topSkills": [{ "name": "AI", "count": 4 }],
  "matchedKeywords": [{ "keyword": "AI", "count": 4 }],
  "matchedLocations": [{ "location": "London", "count": 5 }],
  "hiringSignals": [
    {
      "signalType": "ai_team_expansion",
      "label": "AI team expansion",
      "confidence": "medium",
      "score": 45,
      "evidenceJobFingerprints": ["0adcd377d1d9b02d5ba4a6ea09cc2dcfe2e2c0f169e0d4c132e750894f0cb71c"],
      "evidenceTitles": ["LLM Engineer"],
      "evidenceLocations": ["London"],
      "explanation": "1 new or changed jobs matched AI team expansion."
    }
  ],
  "warnings": [],
  "errors": []
}
```

#### OUTPUT summary

```json
{
  "actorName": "multi-ats-hiring-intent-monitor",
  "runId": "abc123",
  "scrapedAt": "2026-06-06T10:00:00.000Z",
  "datasetId": "defaultDatasetId",
  "keyValueStoreId": "defaultKeyValueStoreId",
  "stateKey": "baseline-monitor",
  "summary": {
    "targetsDiscovered": 2,
    "targetsDetected": 2,
    "targetsSucceeded": 2,
    "targetsFailed": 0,
    "parserSuccessByAts": { "greenhouse": 1, "lever": 1 },
    "parserFailureByAts": {},
    "companiesStateUpdated": 2,
    "companiesStatePreserved": 0,
    "newJobs": 2,
    "changedJobs": 1,
    "removedJobs": 0,
    "unchangedJobs": 22
  },
  "byAtsPlatform": {},
  "byCompany": {},
  "topHiringSignals": [],
  "warnings": [],
  "errors": []
}
```

### Incremental monitoring

Use `stateKey` to keep independent monitors separate. The Actor stores previous snapshots in the named key-value store `multi-ats-hiring-intent-monitor-state-store` under that key. The run `OUTPUT` summary remains in the run's default key-value store and is separate from state.

Recommended scheduled workflow:

1. Run a baseline with `onlyChangesSinceLastRun: false`.
2. Schedule recurring runs with the same `stateKey`.
3. Set `onlyChangesSinceLastRun: true` for recurring delta runs.
4. Consume dataset `job` records for `new`, `changed`, and `removed`.
5. Read KVS `OUTPUT` for run-level warnings, errors, and counters.

`onlyNewSinceLastRun` is a legacy name. It still works, but the behavior is not only new jobs. The mode emits `new`, `changed`, and `removed` records, and excludes `unchanged` jobs. New users should use `onlyChangesSinceLastRun`.

When testing locally with Apify CLI, use `--no-purge` so local storage keeps state between runs.

### Hiring intent signals

Hiring signals are derived from new and changed job records.

Current signal types:

- `ai_team_expansion`
- `sales_expansion`
- `security_investment`
- `new_geo_expansion`
- `revops_investment`
- `customer_support_scaling`

Signals include confidence, score, evidence job fingerprints, titles, locations, and an explanation. They are intended for sales intelligence, recruiting intelligence, account prioritization, and market research workflows.

### Company summaries

When `includeCompanySummary` is `true`, the Actor emits one `company_summary` record per processed company.

Company summaries include:

- processed source URLs
- detected ATS platforms
- current job totals
- emitted job totals
- new/changed/removed/unchanged counts
- top departments
- top locations
- newly seen locations
- top skills
- matched keywords
- matched locations
- hiring signals
- company-level warnings and errors

### Workday/generic limitations

Workday support is best-effort. Many Workday boards are JavaScript-rendered, tenant-specific, or expose jobs only through client-side APIs. This Actor does not run Playwright or browser rendering by default in V1. There is no JavaScript rendering by default in V1, so some Workday pages may return warnings or zero records.

Generic career page support is also best-effort. Custom career pages vary widely, so the generic parser looks for JSON-LD `JobPosting` data and visible public job links. There is no guarantee for every custom career page.

State safety behavior:

- Failed source updates preserve previous state.
- Invalid JSON responses preserve previous state.
- Suspicious zero-job generic extraction preserves previous state.
- This avoids false removed-job records when a page temporarily fails or cannot be parsed safely.

### Interpreting warnings

Common warning meanings:

- `invalid JSON response`: a public JSON endpoint returned a body that was not parseable JSON.
- `HTTP 4xx/5xx`: the public career page or ATS endpoint failed.
- `No allowed ATS parser detected`: a source URL did not match enabled parsers.
- `No jobs extracted from generic career page`: generic extraction could not safely identify jobs.
- `Workday page appears JS-rendered`: server HTML did not expose enough job data.
- Partial source failure: successful sources can update while failed-source state is preserved.

Warnings are surfaced in dataset records and in the KVS `OUTPUT` run summary.

### Local usage

Install dependencies:

```bash
npm install
```

Run full local verification:

```bash
npm run verify
```

Run fixture smoke:

```bash
npm run smoke
```

Run manual live smoke after building:

```bash
npm run build
SMOKE_GREENHOUSE_URL=https://boards.greenhouse.io/example npm run smoke:live
```

Run with Apify CLI:

```bash
npm install -g apify-cli
mkdir -p storage/key_value_stores/default
cp input.json storage/key_value_stores/default/INPUT.json
apify run --no-purge
```

### FAQ

#### Does this scrape LinkedIn?

No. This Actor does not scrape LinkedIn.

#### Does this use private ATS APIs?

No. It uses public career pages and public ATS endpoints only. It does not use login-only APIs, cookies, private candidate systems, or private ATS data.

#### Does this run Playwright or browser rendering?

No. V1 does not use Playwright or JavaScript rendering by default. This keeps the Actor lighter, but it means some JavaScript-only Workday or custom pages may not expose jobs.

#### Can it monitor changes over time?

Yes. Use the same `stateKey` across scheduled runs and set `onlyChangesSinceLastRun` to `true` for delta output.

#### What happens when a board temporarily fails?

The Actor preserves previous state for failed or suspicious sources so a temporary parser, HTTP, invalid JSON, Workday, or generic extraction issue does not create false removals.

#### Are compensation fields guaranteed?

No. Compensation parsing is best-effort. When a board exposes clear salary or compensation data, the Actor maps it. Missing or unparseable compensation is represented as `null`.

#### Is every custom career page supported?

No. Generic career pages are best-effort. Pages with JSON-LD or visible job links work best.

# Actor input Schema

## `companyDomains` (type: `array`):

Optional company domains to use as monitoring targets.

## `careerUrls` (type: `array`):

Optional career page or ATS URLs to use as monitoring targets.

## `atsPlatforms` (type: `array`):

ATS platforms to detect and parse. Keep auto unless you want to restrict the run to specific platforms.

## `keywords` (type: `array`):

Optional keywords for enrichment in matchedKeywords. These enrich records and do not filter jobs.

## `locations` (type: `array`):

Optional locations for enrichment in matchedLocations. These enrich records and do not filter jobs.

## `onlyNewSinceLastRun` (type: `boolean`):

Legacy alias for changes-only mode. When true, emit only new/changed/removed delta records since the previous run.

## `onlyChangesSinceLastRun` (type: `boolean`):

Preferred changes-only mode. When true, emit only new/changed/removed delta records since the previous run and exclude unchanged jobs. Takes priority over onlyNewSinceLastRun.

## `stateKey` (type: `string`):

Key-value store record key used to persist previous job snapshots between runs.

## `includeCompanySummary` (type: `boolean`):

Whether to include one company\_summary record per processed company.

## `includeRawSource` (type: `boolean`):

When true, include rawSource debug metadata on job records. Keep false for normal dataset output.

## `includeDescriptionHtml` (type: `boolean`):

When true, include descriptionHtml on job records. descriptionText is included whenever available.

## `maxJobsPerCompany` (type: `integer`):

Maximum number of jobs to keep per company.

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

Optional Apify proxy configuration for public career page and ATS requests.

## Actor input object example

```json
{
  "atsPlatforms": [
    "auto"
  ],
  "keywords": [],
  "locations": [],
  "onlyNewSinceLastRun": false,
  "onlyChangesSinceLastRun": false,
  "stateKey": "multi-ats-hiring-intent-monitor-state",
  "includeCompanySummary": true,
  "includeRawSource": false,
  "includeDescriptionHtml": false,
  "maxJobsPerCompany": 500
}
```

# Actor output Schema

## `datasetRecords` (type: `string`):

Normalized job and company\_summary records from the default dataset.

## `runSummary` (type: `string`):

User-facing run summary stored as OUTPUT in the default key-value store.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scraping_scrap/multi-ats-hiring-intent-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scraping_scrap/multi-ats-hiring-intent-monitor").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 '{}' |
apify call scraping_scrap/multi-ats-hiring-intent-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-ATS Hiring Intent Monitor",
        "description": "Monitor public career pages and ATS job boards across Greenhouse, Lever, Ashby, SmartRecruiters, Workday, and generic career pages. Detect new, changed, and removed jobs, generate hiring intent signals, and export normalized job records with company summaries.",
        "version": "0.1",
        "x-build-id": "VCtiekvcc0xaPi3jv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraping_scrap~multi-ats-hiring-intent-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraping_scrap-multi-ats-hiring-intent-monitor",
                "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/scraping_scrap~multi-ats-hiring-intent-monitor/runs": {
            "post": {
                "operationId": "runs-sync-scraping_scrap-multi-ats-hiring-intent-monitor",
                "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/scraping_scrap~multi-ats-hiring-intent-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-scraping_scrap-multi-ats-hiring-intent-monitor",
                "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": {
                    "companyDomains": {
                        "title": "Company domains",
                        "type": "array",
                        "description": "Optional company domains to use as monitoring targets.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "careerUrls": {
                        "title": "Career URLs",
                        "type": "array",
                        "description": "Optional career page or ATS URLs to use as monitoring targets.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "atsPlatforms": {
                        "title": "ATS platforms",
                        "type": "array",
                        "description": "ATS platforms to detect and parse. Keep auto unless you want to restrict the run to specific platforms.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "auto",
                                "greenhouse",
                                "lever",
                                "ashby",
                                "workday",
                                "smartrecruiters",
                                "generic"
                            ]
                        },
                        "default": [
                            "auto"
                        ]
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional keywords for enrichment in matchedKeywords. These enrich records and do not filter jobs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional locations for enrichment in matchedLocations. These enrich records and do not filter jobs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "Legacy alias for changes-only mode. When true, emit only new/changed/removed delta records since the previous run.",
                        "default": false
                    },
                    "onlyChangesSinceLastRun": {
                        "title": "Only changes since last run",
                        "type": "boolean",
                        "description": "Preferred changes-only mode. When true, emit only new/changed/removed delta records since the previous run and exclude unchanged jobs. Takes priority over onlyNewSinceLastRun.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State key",
                        "type": "string",
                        "description": "Key-value store record key used to persist previous job snapshots between runs.",
                        "default": "multi-ats-hiring-intent-monitor-state"
                    },
                    "includeCompanySummary": {
                        "title": "Include company summary",
                        "type": "boolean",
                        "description": "Whether to include one company_summary record per processed company.",
                        "default": true
                    },
                    "includeRawSource": {
                        "title": "Include raw source metadata",
                        "type": "boolean",
                        "description": "When true, include rawSource debug metadata on job records. Keep false for normal dataset output.",
                        "default": false
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "When true, include descriptionHtml on job records. descriptionText is included whenever available.",
                        "default": false
                    },
                    "maxJobsPerCompany": {
                        "title": "Maximum jobs per company",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of jobs to keep per company.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration for public career page and ATS requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
