# Lever Jobs Scraper — Company Job Postings API (`nomad-agent/lever-jobs-scraper`) Actor

Extract live job postings from any company's Lever board (jobs.lever.co) via the official public postings API. Pass company slugs and get clean JSON: title, team, location, workplace type, posting date and apply URL. No login, no proxies, no HTML parsing.

- **URL**: https://apify.com/nomad-agent/lever-jobs-scraper.md
- **Developed by:** [Nomad.Dev](https://apify.com/nomad-agent) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Lever Jobs Scraper — Company Job Postings API

Scrape any company's Lever job board through the official public postings API — company slugs in, clean structured postings out.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array (required) | — | Company slugs as used on `jobs.lever.co/<slug>` (full board URLs also accepted). |
| `keyword` | string | — | Case-insensitive substring match on the job title. |
| `titleExclude` | array | — | Drop postings whose title contains any of these substrings (case-insensitive). |
| `locationFilter` | string | — | Case-insensitive substring match on the location. |
| `postedSince` | integer | — | Keep only postings first published within this many days. Postings with no posting date are dropped when this is set. |
| `remoteOnly` | boolean | `false` | Keep only postings Lever flags `workplaceType == "remote"`. |
| `includeDescription` | boolean | `true` | Include a plain-text description snippet per posting. |
| `maxItemsPerCompany` | integer | `100` | Cap postings returned per company (0 = no cap). Each result is a billed event. |
| `maxItems` | integer | `200` | Hard cap on total postings returned (0 = no cap). Each result is a billed event. |
| `onlyNewSinceLastRun` | boolean | `false` | Delta/monitoring mode: only output postings not seen on a previous run made with this flag on (see "Delta mode / monitoring"). |
| `aiEnrichment` | boolean | `false` | Adds `aiKeySkills`/`aiExperienceLevel`/`aiWorkArrangement`/`aiVisaSponsorship` per posting via the Anthropic or Mistral API — BYOK (see "AI enrichment"). |
| `aiProvider` | string | `anthropic` | Which AI provider runs enrichment: `anthropic` (default, uses `anthropicApiKey`) or `mistral` (uses `mistralApiKey`). |
| `anthropicApiKey` | string (secret) | — | Your Anthropic API key. Only used when `aiEnrichment` is on and `aiProvider` is `anthropic`; billed separately by Anthropic, not by this Actor. |
| `aiModel` | string | `claude-haiku-4-5-20251001` | Claude model for AI enrichment (when `aiProvider` is `anthropic`): `claude-haiku-4-5-20251001` (fast/cheap) or `claude-sonnet-4-5` (higher quality). |
| `mistralApiKey` | string (secret) | — | Your Mistral API key. Only used when `aiEnrichment` is on and `aiProvider` is `mistral`; billed separately by Mistral, not by this Actor. |
| `mistralModel` | string | `mistral-small-latest` | Mistral model for AI enrichment (when `aiProvider` is `mistral`): `mistral-small-latest` (default, fast/cheap — matches larger Mistral models on this task), `mistral-medium-latest`, or `mistral-large-latest`. |
| `concurrency` | integer | `8` | Companies fetched in parallel (advanced). |

### What Lever jobs data does this scraper extract?

One flat JSON record per live posting:

| Field | Meaning |
|---|---|
| `ats` | Which ATS served the posting (always `"lever"` here) |
| `company` | Real company display name, resolved from Lever's own job-board page (falls back to the input slug if unresolvable) |
| `id` | Lever's internal posting ID |
| `title` | Job title as posted |
| `department` | Team as categorized by Lever |
| `location` | Location text (may include remote hints) |
| `url` | Direct link to the posting |
| `postedAt` | First-published date (`YYYY-MM-DD`) where provided |
| `employmentType` | Commitment type (Full-time / Part-time / Contract etc.) where provided, otherwise `null` |
| `remote` | `true`/`false`/`null` — `true` when Lever's `workplaceType` is `"remote"`, `false` for any other stated value (on-site, hybrid), `null` only when Lever didn't state a workplace type at all |
| `snippet` | Plain-text description excerpt (optional) |
| `globalId` | Stable composite id `<ats>:<company-slug>:<id>` — unique across the whole ATS-actor family, handy for merging with the Greenhouse/Ashby/Workable Actors or the Company Careers Bundle |
| `warnings` | Array of data-quality notes for this record (e.g. `["postedAt missing"]`); empty array when there's nothing to flag |
| `isNew` | Only present when `onlyNewSinceLastRun` is on — always `true` (already-seen postings are dropped, never emitted with `isNew: false`) |
| `aiKeySkills` | Only present when `aiEnrichment` is on — array of skills/technologies explicitly named in the posting text, never invented |
| `aiExperienceLevel` | Only present when `aiEnrichment` is on — one of `entry`/`mid`/`senior`/`lead`/`unknown` |
| `aiWorkArrangement` | Only present when `aiEnrichment` is on — one of `onsite`/`hybrid`/`remote`/`unknown` |
| `aiVisaSponsorship` | Only present when `aiEnrichment` is on — `true`/`false` only if the posting explicitly states a policy, otherwise `null` |

### How to scrape Lever jobs with this Actor

1. Enter one or more **company slugs** (`mistral`, `voleon`, `attentive`). Open the company's careers page and look for jobs.lever.co/<slug> in job links.
2. Optionally set `keyword` / `titleExclude` / `locationFilter` / `postedSince` / `remoteOnly` / caps.
3. Run and export JSON, CSV or Excel — or call it over the API:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nomad-jobs/lever-jobs-scraper").call(run_input={
    "companies": ["mistral", "voleon", "attentive"],
    "keyword": "engineer",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["company"], "|", item["title"], item["url"])
````

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nomad-jobs~lever-jobs-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["mistral", "voleon", "attentive"]}'
```

### Output example

```json
{
  "ats": "lever",
  "company": "Mistral AI",
  "id": "7894fd8a-ffc9-4c89-87f0-f8a7b695cf01",
  "title": "Account Executive – AI for Citizens",
  "department": "Business",
  "location": "Paris",
  "url": "https://jobs.lever.co/mistral/7894fd8a-ffc9-4c89-87f0-f8a7b695cf01",
  "postedAt": "2025-07-28",
  "employmentType": "Full-time",
  "remote": false,
  "snippet": "We are hiring an Account Executive...",
  "globalId": "lever:mistral:7894fd8a-ffc9-4c89-87f0-f8a7b695cf01",
  "warnings": []
}
```

### Delta mode / monitoring

Set `onlyNewSinceLastRun: true` to turn this Actor into a "what's new" monitor. Postings already seen on a previous run made with this flag on are dropped before push — you are not billed for them, so pairing this with an Apify schedule (cron) means every run only returns, and only charges for, postings that showed up since the last flagged run.

How it works: seen postings are tracked in a dedicated key-value store, keyed by each posting's `globalId`, capped at roughly 50,000 entries (oldest evicted first). The first run made with the flag on has nothing to compare against yet, so it emits everything — all `isNew: true`. Every emitted record gets `isNew: true` stamped on it; there's no `isNew: false` in the output, since unseen postings just aren't included.

Runs made with the flag off never read or write this cache — turning it on and off between runs is safe and has no side effects on normal runs.

### AI enrichment

Turn on `aiEnrichment` and supply your own `anthropicApiKey` (or `mistralApiKey`, with `aiProvider: "mistral"`) to add four AI-extracted fields to every posting:

| Field | Meaning |
|---|---|
| `aiKeySkills` | Specific skills/technologies/tools explicitly named in the title or description — the model is instructed to never invent one. |
| `aiExperienceLevel` | One of `entry` / `mid` / `senior` / `lead` / `unknown`. |
| `aiWorkArrangement` | One of `onsite` / `hybrid` / `remote` / `unknown`. |
| `aiVisaSponsorship` | `true` / `false` only when the posting explicitly states a sponsorship policy, otherwise `null`. |

The extraction prompt is explicit about never guessing: when the text doesn't clearly support a value you get `"unknown"` / `null` / an empty array, not a fabricated answer. Pick the model with `aiModel` (Anthropic: `claude-haiku-4-5-20251001` default, fast/cheap, or `claude-sonnet-4-5` higher quality) or `mistralModel` (Mistral: `mistral-small-latest` default — matches larger Mistral models on this task, `mistral-medium-latest`, `mistral-large-latest`).

Postings are batched (~12 per call) through whichever provider's API you picked (`aiProvider`). **Your Anthropic or Mistral API key is billed separately by that provider, not by this Actor.** Rough cost with Haiku or Mistral Small: enriching 100 postings runs well under $0.05 in provider token spend (short prompts, small JSON replies); Sonnet/Mistral Large cost roughly 4-5x that for the same batch.

Enrichment needs a posting's description text even when you have `includeDescription` off — this Actor fetches it internally for enrichment either way, then still honors your `includeDescription` choice for what actually ends up in the output `snippet` field.

If `aiEnrichment` is on but no matching key is available (`anthropicApiKey`/`ANTHROPIC_API_KEY` for `aiProvider: "anthropic"`, or `mistralApiKey`/`MISTRAL_API_KEY` for `aiProvider: "mistral"`), enrichment is skipped: you get one extra dataset row explaining why (`warnings: ["aiEnrichment skipped: no anthropicApiKey or mistralApiKey provided"]`), a run status message, and every other posting is still returned normally, just without the `ai*` fields.

This is the same class of field fantastic-jobs' `career-site-api` prices a whole tier on (`ai_key_skills`, work arrangement, visa signals) — comparable output here, opt-in and BYOK instead of bundled into every row's price.

### Integrations

Export results as JSON, CSV or Excel/XLSX, or pipe them straight into Make, Zapier or n8n. Call this Actor synchronously with `run-sync-get-dataset-items`, or plug it into any AI agent through the [Apify MCP server](https://apify.com/apify/actors-mcp-server).

### Pricing

Pay per event: **$0.05 per Actor start** and **$0.004 per posting returned**.
100 postings ≈ $0.45. No subscription — pay only for what you fetch.

If you turn on `aiEnrichment`, your Anthropic or Mistral key is billed separately by that provider for the enrichment calls themselves — see "AI enrichment" above for a rough per-100-postings cost estimate. Delta mode (`onlyNewSinceLastRun`) only *reduces* cost: already-seen postings are dropped before the billed push step.

### Use cases

- Track hiring at specific Lever-powered companies
- Aggregate startup careers pages into one feed
- Recruiting and competitive-hiring intelligence
- Reliable ATS-direct data for job boards and agents

### FAQ

**Is it legal to scrape Lever jobs?**
The data comes from the ATS providers' official, public, unauthenticated JSON APIs — the same data any visitor sees on the company's careers page. Review the providers' terms for your use case.

**Do I need an API key or login?**
No. These are public job-board APIs — no authentication of any kind.

**What if a company isn't found?**
It is logged and skipped — the run continues with the other companies. Full board URLs are also accepted and reduced to slugs automatically.

**Can `remote` actually be `false`, or only `true`/`null`?**
It can be all three. `remote` is `true` when Lever states `workplaceType: "remote"`, `false` when Lever states any other workplace type (on-site, hybrid), and `null` only when Lever didn't state a workplace type at all.

**How fresh is the data?**
Every run hits the ATS APIs live. No caching layer in between.

**Something broken or missing?**
Open an issue on the Actor's **Issues** tab — it is monitored and fixes ship fast.

### Related Actors

- [Greenhouse Jobs Scraper — Company Job Boards](https://apify.com/nomad-jobs/greenhouse-jobs-scraper)
- [Ashby Jobs Scraper — Company Job Boards API](https://apify.com/nomad-jobs/ashby-jobs-scraper)
- [Workable Jobs Scraper — Company Job Boards](https://apify.com/nomad-jobs/workable-jobs-scraper)
- [Company Careers Scraper — Greenhouse Lever Ashby](https://apify.com/nomad-jobs/company-careers-bundle)
- [Web Developer Jobs Scraper — 10 Boards in One](https://apify.com/nomad-jobs/web-dev-bundle)
- [LinkedIn Jobs Scraper — No Login, No Cookies](https://apify.com/nomad-jobs/linkedin-scraper)

# Actor input Schema

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

Company slugs as used on their ATS board (full board URLs also accepted). Open the company's careers page and look for jobs.lever.co/<slug> in job links.

## `keyword` (type: `string`):

Optional case-insensitive substring match on the job title (e.g. "engineer").

## `titleExclude` (type: `array`):

Drop postings whose title contains any of these substrings (case-insensitive). Example: \["intern", "staffing"].

## `locationFilter` (type: `string`):

Optional case-insensitive substring match on the location (e.g. "remote", "london").

## `postedSince` (type: `integer`):

Only keep postings first published within this many days. Leave empty (or 0) for no date filter. When this is set, postings the source didn't give a posting date for are dropped rather than guessed at.

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

Keep only postings Lever flags workplaceType="remote". Postings marked on-site/hybrid, or where Lever didn't state a workplace type, are excluded.

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

Include a plain-text description snippet per posting. Turn off for lighter, faster output.

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

Cap postings returned per company. Each posting returned is a billed result, so this keeps one large board from dominating the run's cost. 0 = no cap.

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

Hard cap on total postings returned across all companies. Each posting returned is billed as a paid result — raise this only as high as you actually need. 0 = no cap (not recommended for large company lists).

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

Delta/monitoring mode: only output postings not seen in a previous run that also had this flag on. Already-seen postings are dropped before push (not billed), so this is the cheapest way to run this Actor on a cron schedule and only pay for genuinely new postings. State is tracked per Actor in a dedicated key-value store, keyed by each posting's globalId. See README “Delta mode / monitoring”.

## `aiEnrichment` (type: `boolean`):

Adds aiKeySkills / aiExperienceLevel / aiWorkArrangement / aiVisaSponsorship to every posting via the Anthropic or Mistral API (pick which below). Requires your own API key for the provider you pick — billed separately by that provider, not by this Actor (see README “AI enrichment”). If turned on without a matching key, enrichment is skipped (with a warning) and postings are still returned normally, without the ai\* fields.

## `aiProvider` (type: `string`):

Which AI provider runs enrichment (only relevant when “AI enrichment” is on). "anthropic" (default) uses Claude via anthropicApiKey. "mistral" uses a Mistral model via mistralApiKey instead — pick this if you'd rather bring a Mistral key than an Anthropic one.

## `anthropicApiKey` (type: `string`):

Your Anthropic API key (sk-ant-…). Only used when “AI enrichment” is on and aiProvider is "anthropic"; billed separately by Anthropic. Not required unless aiEnrichment is on.

## `aiModel` (type: `string`):

Claude model used for AI enrichment when aiProvider is "anthropic" (only relevant when “AI enrichment” is on). Haiku is fast and inexpensive; Sonnet gives higher-quality extraction on longer, more nuanced descriptions.

## `mistralApiKey` (type: `string`):

Your Mistral API key. Only used when “AI enrichment” is on and aiProvider is "mistral"; billed separately by Mistral. Not required unless aiEnrichment is on with aiProvider=mistral.

## `mistralModel` (type: `string`):

Mistral model used for AI enrichment when aiProvider is "mistral" (only relevant when “AI enrichment” is on). Small is the default — testing found it matches larger Mistral models on this extraction task (small, well-scoped fields) at a fraction of the cost.

## `concurrency` (type: `integer`):

How many companies to fetch at the same time. Higher is faster but hits the source API harder — the default is a safe, fast setting for almost every run.

## Actor input object example

```json
{
  "companies": [
    "mistral",
    "voleon",
    "attentive"
  ],
  "remoteOnly": false,
  "includeDescription": true,
  "maxItemsPerCompany": 100,
  "maxItems": 200,
  "onlyNewSinceLastRun": false,
  "aiEnrichment": false,
  "aiProvider": "anthropic",
  "aiModel": "claude-haiku-4-5-20251001",
  "mistralModel": "mistral-small-latest",
  "concurrency": 8
}
```

# 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": [
        "mistral",
        "voleon",
        "attentive"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nomad-agent/lever-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 = { "companies": [
        "mistral",
        "voleon",
        "attentive",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nomad-agent/lever-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 '{
  "companies": [
    "mistral",
    "voleon",
    "attentive"
  ]
}' |
apify call nomad-agent/lever-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lever Jobs Scraper — Company Job Postings API",
        "description": "Extract live job postings from any company's Lever board (jobs.lever.co) via the official public postings API. Pass company slugs and get clean JSON: title, team, location, workplace type, posting date and apply URL. No login, no proxies, no HTML parsing.",
        "version": "0.1",
        "x-build-id": "sx7fRPUTlUtarfIMM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nomad-agent~lever-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nomad-agent-lever-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/nomad-agent~lever-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nomad-agent-lever-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/nomad-agent~lever-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nomad-agent-lever-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",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "Company slugs as used on their ATS board (full board URLs also accepted). Open the company's careers page and look for jobs.lever.co/<slug> in job links.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Optional case-insensitive substring match on the job title (e.g. \"engineer\")."
                    },
                    "titleExclude": {
                        "title": "Exclude titles containing",
                        "type": "array",
                        "description": "Drop postings whose title contains any of these substrings (case-insensitive). Example: [\"intern\", \"staffing\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationFilter": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Optional case-insensitive substring match on the location (e.g. \"remote\", \"london\")."
                    },
                    "postedSince": {
                        "title": "Posted in the last N days",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep postings first published within this many days. Leave empty (or 0) for no date filter. When this is set, postings the source didn't give a posting date for are dropped rather than guessed at."
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Keep only postings Lever flags workplaceType=\"remote\". Postings marked on-site/hybrid, or where Lever didn't state a workplace type, are excluded.",
                        "default": false
                    },
                    "includeDescription": {
                        "title": "Include description",
                        "type": "boolean",
                        "description": "Include a plain-text description snippet per posting. Turn off for lighter, faster output.",
                        "default": true
                    },
                    "maxItemsPerCompany": {
                        "title": "Max items per company",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap postings returned per company. Each posting returned is a billed result, so this keeps one large board from dominating the run's cost. 0 = no cap.",
                        "default": 100
                    },
                    "maxItems": {
                        "title": "Max items (total)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on total postings returned across all companies. Each posting returned is billed as a paid result — raise this only as high as you actually need. 0 = no cap (not recommended for large company lists).",
                        "default": 200
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "Delta/monitoring mode: only output postings not seen in a previous run that also had this flag on. Already-seen postings are dropped before push (not billed), so this is the cheapest way to run this Actor on a cron schedule and only pay for genuinely new postings. State is tracked per Actor in a dedicated key-value store, keyed by each posting's globalId. See README “Delta mode / monitoring”.",
                        "default": false
                    },
                    "aiEnrichment": {
                        "title": "AI enrichment",
                        "type": "boolean",
                        "description": "Adds aiKeySkills / aiExperienceLevel / aiWorkArrangement / aiVisaSponsorship to every posting via the Anthropic or Mistral API (pick which below). Requires your own API key for the provider you pick — billed separately by that provider, not by this Actor (see README “AI enrichment”). If turned on without a matching key, enrichment is skipped (with a warning) and postings are still returned normally, without the ai* fields.",
                        "default": false
                    },
                    "aiProvider": {
                        "title": "AI provider",
                        "enum": [
                            "anthropic",
                            "mistral"
                        ],
                        "type": "string",
                        "description": "Which AI provider runs enrichment (only relevant when “AI enrichment” is on). \"anthropic\" (default) uses Claude via anthropicApiKey. \"mistral\" uses a Mistral model via mistralApiKey instead — pick this if you'd rather bring a Mistral key than an Anthropic one.",
                        "default": "anthropic"
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API key",
                        "type": "string",
                        "description": "Your Anthropic API key (sk-ant-…). Only used when “AI enrichment” is on and aiProvider is \"anthropic\"; billed separately by Anthropic. Not required unless aiEnrichment is on."
                    },
                    "aiModel": {
                        "title": "AI enrichment model (Anthropic)",
                        "enum": [
                            "claude-haiku-4-5-20251001",
                            "claude-sonnet-4-5"
                        ],
                        "type": "string",
                        "description": "Claude model used for AI enrichment when aiProvider is \"anthropic\" (only relevant when “AI enrichment” is on). Haiku is fast and inexpensive; Sonnet gives higher-quality extraction on longer, more nuanced descriptions.",
                        "default": "claude-haiku-4-5-20251001"
                    },
                    "mistralApiKey": {
                        "title": "Mistral API key",
                        "type": "string",
                        "description": "Your Mistral API key. Only used when “AI enrichment” is on and aiProvider is \"mistral\"; billed separately by Mistral. Not required unless aiEnrichment is on with aiProvider=mistral."
                    },
                    "mistralModel": {
                        "title": "AI enrichment model (Mistral)",
                        "enum": [
                            "mistral-small-latest",
                            "mistral-medium-latest",
                            "mistral-large-latest"
                        ],
                        "type": "string",
                        "description": "Mistral model used for AI enrichment when aiProvider is \"mistral\" (only relevant when “AI enrichment” is on). Small is the default — testing found it matches larger Mistral models on this extraction task (small, well-scoped fields) at a fraction of the cost.",
                        "default": "mistral-small-latest"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "How many companies to fetch at the same time. Higher is faster but hits the source API harder — the default is a safe, fast setting for almost every run.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
