# Lever Postings API — Tech Jobs, Salaries & ATS Data (`logiover/lever-postings-scraper`) Actor

Unofficial Lever Postings API in one Apify actor. Scrape jobs and structured salary data from any Lever-powered career page — Netflix, Spotify, Shopify, Mixpanel, Lyra Health & 5,000+ more. Pure HTTP, no auth, structured workplaceType, global + EU instances.

- **URL**: https://apify.com/logiover/lever-postings-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Lever Postings API — Apify Actor

> **Unofficial Lever Postings API in one actor.** Scrape jobs, structured content blocks, and *real salary data* from any company on Lever — Netflix, Spotify, Shopify, Mixpanel, Lyra Health, KKR, Eventbrite, Reddit and thousands more.

Pure HTTP. No authentication. No headless browser. Sub-second responses per board. Supports both `global` (api.lever.co) and `EU` (api.eu.lever.co) Lever instances. Server-side filtering forwarded to Lever's native API for fastest possible results.

---

### Why this actor

Lever's [Postings API](https://github.com/lever/postings-api) is public but raw — you need to know the endpoints, handle two regional instances, normalize a confusing mix of `text` vs `title`, `categories.team` vs top-level fields, deal with optional `salaryRange` objects, and apply client-side post-filters Lever's server doesn't support (workplaceType, country, salary thresholds).

This actor does all of that. You get **structured, normalized, downstream-ready records** for any Lever board. One input, hundreds of jobs.

#### What makes Lever data special

Compared to other ATS platforms, Lever ships uniquely valuable structured fields:

| Field | Why it matters |
|---|---|
| `salaryRange` | Structured `{currency, interval, min, max}` — not buried in description HTML like Greenhouse. Filter, sort, model on it. |
| `workplaceType` | Explicit `remote`, `hybrid`, `on-site`, or `unspecified`. Remote-job pipelines love this. |
| `lists[]` | Structured Qualifications, Responsibilities, etc. as separate `{text, content}` blocks. No regex needed to parse requirements. |
| `country` | ISO 3166-1 alpha-2. Easy multi-country slicing. |
| `categories.allLocations` | Array of all eligible locations for multi-city postings. |

---

### How it compares

|  | This actor (Lever) | Generic web scrapers | Other Apify Lever actors |
|---|---|---|---|
| Public Lever API | ✅ Direct | ❌ HTML parsing | Some |
| Server-side filtering | ✅ team/dept/location/commitment/level | ❌ | Limited |
| EU instance support | ✅ Toggle in input | ❌ | Rare |
| Salary parsing | ✅ Structured object | ❌ Regex from text | Limited |
| Structured `lists[]` | ✅ Preserved | ❌ Flattened | Limited |
| Multi-site batch | ✅ Concurrent | Manual loops | Sometimes |
| Workplace type filter | ✅ | ❌ | ❌ |
| No-auth, no-proxy | ✅ | Often proxied | ✅ |
| Maintenance burden | ✅ Stable public API | High (DOM changes) | Varies |

---

### Modes

#### `jobs` — list mode (default)

Fetch all currently-published postings from one or more Lever sites in parallel.

```json
{
  "mode": "jobs",
  "sites": ["leverdemo", "lever"],
  "instance": "global",
  "concurrency": 5
}
````

Returns one record per posting, fully normalized. With multiple sites, requests run in parallel up to your `concurrency` setting (default 5, max 20).

#### `jobDetail` — deep detail mode

Fetch specific postings by UUID. Useful when you already have job IDs from elsewhere (your CRM, a database, the `jobs` mode output) and want fresh data.

```json
{
  "mode": "jobDetail",
  "sites": ["leverdemo"],
  "jobIds": [
    "33538a2f-d27d-4a96-8f05-fa4b0e4d940e",
    "5ac21346-8e0c-4494-8e7a-3eb92ff77902"
  ]
}
```

Output is identical in shape to `jobs` mode — same normalization, same fields.

***

### Filtering: server-side vs client-side

#### Server-side (fast — Lever does the work)

Lever supports native filtering on **team, department, location, commitment, level**. Set any of these in the input and they're forwarded as query parameters. Multiple values are OR'ed; different filters are AND'ed. **Filters are case-sensitive** (Lever's rule).

```json
{
  "mode": "jobs",
  "sites": ["leverdemo"],
  "team": ["Engineering", "Product"],
  "commitment": ["Full Time"]
}
```

This calls Lever as: `?team=Engineering&team=Product&commitment=Full%20Time&mode=json` — only matching postings are downloaded.

#### Client-side (after fetch — workplace, country, salary, title)

Lever doesn't support filtering on these, so the actor does it after the fetch:

| Filter | Effect |
|---|---|
| `filterTitleKeywords` | Keep postings whose title contains any of these (case-insensitive) |
| `filterWorkplaceTypes` | Keep only chosen workplace types (`remote`, `hybrid`, `on-site`, `unspecified`) |
| `filterCountries` | Keep only matching ISO country codes |
| `filterSalaryMin` | Keep only postings with disclosed `salaryMin >= threshold` |

```json
{
  "mode": "jobs",
  "sites": ["leverdemo"],
  "filterTitleKeywords": ["engineer", "developer"],
  "filterWorkplaceTypes": ["remote", "hybrid"],
  "filterCountries": ["US", "CA"],
  "filterSalaryMin": 120000
}
```

***

### Pagination — Lever native

Lever uses offset pagination via `skip` and `limit`. The actor exposes both:

```json
{
  "mode": "jobs",
  "sites": ["bigemployer"],
  "skip": 100,
  "limit": 50
}
```

For most use cases you don't need pagination — Lever returns all published postings by default. Use `maxResultsPerSite` if you want a hard local cap.

***

### Who this is for

#### 🎯 Recruitment intelligence / talent acquisition

Build a real-time pipeline of every job a target company is hiring for. Lever's structured salary data lets you benchmark compensation per role/level/region without manual parsing.

#### 📊 HR tech & ATS market analytics

Track which companies are using Lever, hiring velocity, role mix, remote/hybrid split, salary disclosure trends. Compare against Greenhouse, Workday, Ashby.

#### 🤖 AI agents and LLM context

Lever's plaintext fields (`*Plain` variants) are LLM-ready — no HTML cleanup required. Structured `lists[]` already separates Qualifications from Duties for clean RAG ingestion.

#### 💼 Job boards & aggregators

Ingest from any Lever-powered career page into your job feed with one input. Multi-site batching and EU instance support cover global employers.

#### 🏢 Competitive sales intelligence

Headcount growth, new team formation, geographic expansion, comp shifts — all visible from public postings. Lever's `createdAt` field gives you precise hiring velocity.

***

### Popular companies on Lever

A non-exhaustive snapshot of well-known Lever-powered career pages (verify the exact site name before scraping):

**Tech:** Netflix, Spotify, Shopify, Mixpanel, Segment, Quora, Twitch (historic), Lyft, Discord, KKR, Lattice

**Consumer / digital health:** Lyra Health, LifeStance Health, Vohra Physicians

**Fintech / banking:** SEB (EU instance), Outgo

**Education / EdTech:** Top Hat (mentioned in their own postings)

**Consulting / services:** CI\&T, KPMG (example listed in Lever's docs)

**Job aggregators powered by Lever:** Jobgether

> 💡 **Tip:** To find a company's Lever site name, open their career page. If the URL is `https://jobs.lever.co/SITENAME`, that's your input. EU customers will have `https://jobs.eu.lever.co/SITENAME` — set instance to `eu`.

***

### Recipes

#### Recipe 1 — Daily remote-job feed across multiple employers

```json
{
  "mode": "jobs",
  "sites": ["lyrahealth", "mixpanel", "segment", "quora"],
  "filterWorkplaceTypes": ["remote", "hybrid"],
  "concurrency": 4
}
```

Schedule daily, push to your downstream warehouse.

#### Recipe 2 — Engineering roles >= $150K in the US

```json
{
  "mode": "jobs",
  "sites": ["netflix-jobs", "shopify"],
  "team": ["Engineering"],
  "filterCountries": ["US"],
  "filterSalaryMin": 150000
}
```

Server-side team filter + client-side country and salary filters.

#### Recipe 3 — Refresh tracked job UUIDs

```json
{
  "mode": "jobDetail",
  "sites": ["leverdemo"],
  "jobIds": ["33538a2f-d27d-4a96-8f05-fa4b0e4d940e", "1897fca1-502e-4511-b279-de479e99fbea"]
}
```

Detect when a posting is removed (returns 404, the actor logs it and continues) — feeds into a "job closed" signal.

#### Recipe 4 — EU-only employer

```json
{
  "mode": "jobs",
  "sites": ["seb"],
  "instance": "eu",
  "concurrency": 1
}
```

The `instance` toggle swaps the base URL to `api.eu.lever.co` — same schema.

#### Recipe 5 — Cap output for testing

```json
{
  "mode": "jobs",
  "sites": ["bigemployer"],
  "limit": 10,
  "maxResultsPerSite": 5
}
```

`limit` is Lever's native server-side cap; `maxResultsPerSite` is the actor's hard local cap after filtering.

***

### Output format

Each posting is a flat, normalized record. Sample (truncated):

```json
{
  "_mode": "jobs",
  "site": "leverdemo",
  "instance": "global",
  "id": "33538a2f-d27d-4a96-8f05-fa4b0e4d940e",
  "title": "Senior Software Engineer",
  "team": "Engineering",
  "department": "Product",
  "location": "San Francisco, CA",
  "allLocations": ["San Francisco, CA", "Remote - US"],
  "commitment": "Full Time",
  "level": "Senior",
  "country": "US",
  "workplaceType": "hybrid",
  "createdAt": 1553186035299,
  "createdAtIso": "2026-03-21T15:13:55.299Z",
  "hostedUrl": "https://jobs.lever.co/leverdemo/33538a2f-...",
  "applyUrl": "https://jobs.lever.co/leverdemo/33538a2f-.../apply",

  "opening": "<div>Welcome to our team...</div>",
  "openingPlain": "Welcome to our team...",
  "description": "<div>...</div>",
  "descriptionPlain": "About us...",
  "descriptionBody": "<div>Main role description...</div>",
  "descriptionBodyPlain": "Main role description...",
  "additional": "<div>EEO statement...</div>",
  "additionalPlain": "EEO statement...",
  "fullDescription": "<div>...</div><h3>Qualifications</h3><ul>...</ul>",
  "fullDescriptionPlain": "About us... Main role... Qualifications: ...",

  "lists": [
    {
      "text": "Qualifications",
      "content": "<li>Bachelor's degree in CS or equivalent</li><li>5+ years of backend experience</li>"
    },
    {
      "text": "Responsibilities",
      "content": "<li>Design and ship distributed systems</li><li>Mentor junior engineers</li>"
    }
  ],

  "salaryRange": {
    "currency": "USD",
    "interval": "per-year-salary",
    "min": 150000,
    "max": 220000
  },
  "salaryMin": 150000,
  "salaryMax": 220000,
  "salaryCurrency": "USD",
  "salaryInterval": "per-year-salary",
  "salaryDescription": "<p>Plus equity and a sign-on bonus.</p>",
  "salaryDescriptionPlain": "Plus equity and a sign-on bonus.",

  "scrapedAt": "2026-05-13T12:26:29.650Z"
}
```

> **Note:** Many fields are optional in Lever's schema. `salaryRange`, `workplaceType`, `country`, `categories.commitment`, `categories.location`, and `categories.department` may all be absent depending on how the employer configured their postings. The actor returns `null` (or an empty array for `allLocations` / `lists`) when a field is missing.

***

### Performance & quotas

| Setup | Time |
|---|---|
| 1 small site (~20 postings) | < 1 second |
| 1 medium site (~200 postings) | 1-2 seconds |
| 10 sites in parallel | 2-5 seconds |
| 50 sites in parallel (concurrency=10) | 15-30 seconds |

Lever's GET endpoints have no documented rate limit and have proven generous in practice. The actor uses linear backoff on transient errors and 5× backoff on the rare 429 (just in case). Concurrency is capped at 20.

***

### FAQ

#### Q: Do I need a Lever API key?

**No.** The Postings API (this actor) is fully public and works without any credentials. Lever has a separate Data API (`/v1/`) for authenticated CRM-style access — that one is out of scope for this actor.

#### Q: Are confidential or internal postings exposed?

**No.** Only postings in the `published` state are visible via this API — exactly the same postings a candidate would see on the company's Lever-hosted career page. Internal, confidential, draft, and closed postings are completely hidden.

#### Q: How fresh is the data?

Real-time. Each actor run hits Lever's API directly, no caching layer.

#### Q: A site returns 404 — what does that mean?

Either the site name is misspelled, or the company is on the **other instance** (try toggling `instance` to `eu`). EU customers (especially European employers) are commonly on `api.eu.lever.co` instead of the global instance.

#### Q: How do I find a company's Lever site name?

Visit their career page. The URL `https://jobs.lever.co/SITENAME` or `https://jobs.eu.lever.co/SITENAME` reveals it. The site name is case-sensitive.

#### Q: What's the difference between `description` and `descriptionBody`?

- `description` = opening + body (combined)
- `descriptionBody` = body only, without the intro paragraph
- `opening` = just the intro paragraph (often the company boilerplate)
- `additional` = closing content (EEO statement, equal opportunity disclaimers)
- `fullDescription` = the actor's convenience concatenation of all sections + structured lists

Each has a `*Plain` text-only variant.

#### Q: Why are the HTML fields not entity-encoded?

Lever returns content already HTML-decoded — `<div>` is `<div>`, not `&lt;div&gt;`. This is a Lever-specific behavior and differs from Greenhouse. No decoding needed on your end.

#### Q: Can I filter by salary or workplace type on the server?

No. Lever's server-side filters are only `team`, `department`, `location`, `commitment`, `level`. Workplace type, country, and salary filters are client-side (the actor applies them after fetching).

#### Q: How is `commitment` different from `workplaceType`?

- `commitment` = employment type (Full Time, Part Time, Internship, Contract) — set by the employer
- `workplaceType` = work environment (on-site, remote, hybrid, unspecified) — Lever's enum

#### Q: How is the actor priced?

Pay per result. See the Pricing tab on this actor's Apify Store page for current rates per mode.

#### Q: Does this actor support the XML or HTML modes?

No — JSON only. XML and HTML output modes are designed for embedding on a company's own career page and aren't useful for data pipelines.

***

### Related actors — the Tech Career Pages portfolio

This actor is part of a family of ATS scrapers covering modern tech employers:

- **[Welcome to the Jungle Jobs](https://apify.com/)** — European tech ecosystem, Algolia-powered
- **[Greenhouse Job Board API](https://apify.com/)** — Stripe, Airbnb, Anthropic, Mistral AI, Doctolib
- **Lever Postings API** *(this actor)* — Netflix, Spotify, Shopify, Mixpanel
- More platforms coming soon

> 💡 **Tip:** Combine Lever + Greenhouse coverage to capture ~70% of the modern tech employer hiring graph.

***

### Changelog

#### 1.0 — Initial release

- 2 modes: `jobs`, `jobDetail`
- Global + EU instance support
- All 5 server-side filters (team, department, location, commitment, level)
- 4 client-side filters (titleKeywords, workplaceTypes, countries, salaryMin)
- Lever-native `skip`, `limit`, `group` pass-through
- Flat normalized output with structured `lists[]`, salary, and full content
- Concurrent multi-site fetching (up to 20 parallel)
- 404-aware retry with 5× backoff on 429

***

### Support

Issues, edge cases, or feature requests? Use the Apify actor page's **Issues** tab. Pull requests welcome via GitHub if the source repository is opened.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: a list of jobs from one or more Lever sites, or a deep detail object for specific posting IDs.

## `sites` (type: `array`):

One or more Lever site names. For 'jobDetail' mode only the first site is used. Case-sensitive. Try 'leverdemo' for a guaranteed-working smoke test.

## `instance` (type: `string`):

Lever runs two regional instances. Most companies are on 'global' (api.lever.co). EU customers (frequent for European-only employers) are on 'eu' (api.eu.lever.co). If you get 404s on 'global', try 'eu'.

## `jobIds` (type: `array`):

List of posting UUIDs to fetch. Required when mode = jobDetail. Example: 5ac21346-8e0c-4494-8e7a-3eb92ff77902

## `team` (type: `array`):

Lever-native filter. Postings are filtered server-side. Case-sensitive — must match exactly (e.g. 'Engineering' not 'engineering'). Multiple values are OR'ed.

## `department` (type: `array`):

Lever-native filter. Case-sensitive. Multiple values are OR'ed.

## `location` (type: `array`):

Lever-native filter. Case-sensitive. Multiple values are OR'ed. Example: 'San Francisco' or 'Remote - US'.

## `commitment` (type: `array`):

Lever-native filter. Case-sensitive. Examples: 'Full Time', 'Part Time', 'Internship', 'Contract'. Multiple values are OR'ed.

## `level` (type: `array`):

Lever-native filter. Case-sensitive. Values are customer-defined (e.g. 'Senior', 'Junior', 'Director').

## `limit` (type: `integer`):

Forwarded as Lever's ?limit= parameter. Caps the number of postings the server returns per board. Leave at 0 for no cap.

## `skip` (type: `integer`):

Forwarded as Lever's ?skip= parameter. Use for pagination: skip N postings from the start before returning results.

## `group` (type: `string`):

Lever's ?group= parameter. When set, the API returns postings grouped by the chosen category. Leave as 'none' for ungrouped output.

## `filterTitleKeywords` (type: `array`):

Client-side: keep only postings whose title contains any of these strings (case-insensitive). Useful for job-role targeting (e.g. 'engineer', 'designer'). Multiple keywords are OR'ed.

## `filterWorkplaceTypes` (type: `array`):

Client-side: keep only postings with these workplace types. Lever's native enum values.

## `filterCountries` (type: `array`):

Client-side: keep only postings whose 'country' field matches one of these ISO 3166-1 alpha-2 codes (e.g. 'US', 'GB', 'DE'). Case-insensitive.

## `filterSalaryMin` (type: `integer`):

Client-side: keep only postings whose salaryRange.min is >= this number. Postings WITHOUT a disclosed salary are dropped when this filter is active. Set to 0 to disable.

## `maxResultsPerSite` (type: `integer`):

Hard cap applied after all filters. 0 = unlimited. Useful for testing or controlling cost.

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

How many sites to fetch in parallel. 5 is a safe default. Higher = faster, but Lever may rate-limit you on huge batches.

## Actor input object example

```json
{
  "mode": "jobs",
  "sites": [
    "leverdemo"
  ],
  "instance": "global",
  "jobIds": [],
  "team": [],
  "department": [],
  "location": [],
  "commitment": [],
  "level": [],
  "limit": 0,
  "skip": 0,
  "group": "none",
  "filterTitleKeywords": [],
  "filterWorkplaceTypes": [],
  "filterCountries": [],
  "filterSalaryMin": 0,
  "concurrency": 5
}
```

# Actor output Schema

## `_mode` (type: `string`):

Actor mode that produced this record.

## `site` (type: `string`):

Lever account name.

## `instance` (type: `string`):

global or eu.

## `id` (type: `string`):

UUID of the posting.

## `title` (type: `string`):

Job title.

## `team` (type: `string`):

Internal team name.

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

Department / org unit.

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

Primary office location.

## `commitment` (type: `string`):

Employment type.

## `country` (type: `string`):

ISO 3166-1 alpha-2 country code.

## `workplaceType` (type: `string`):

on-site, remote, hybrid, or unspecified.

## `salaryMin` (type: `string`):

Minimum salary disclosed by the employer.

## `salaryMax` (type: `string`):

Maximum salary disclosed.

## `salaryCurrency` (type: `string`):

Salary currency.

## `createdAtIso` (type: `string`):

Posting creation timestamp.

## `hostedUrl` (type: `string`):

Public Lever-hosted page.

## `scrapedAt` (type: `string`):

When this record was produced.

# 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 = {
    "sites": [
        "leverdemo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/lever-postings-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 = { "sites": ["leverdemo"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/lever-postings-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 '{
  "sites": [
    "leverdemo"
  ]
}' |
apify call logiover/lever-postings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lever Postings API — Tech Jobs, Salaries & ATS Data",
        "description": "Unofficial Lever Postings API in one Apify actor. Scrape jobs and structured salary data from any Lever-powered career page — Netflix, Spotify, Shopify, Mixpanel, Lyra Health & 5,000+ more. Pure HTTP, no auth, structured workplaceType, global + EU instances.",
        "version": "1.0",
        "x-build-id": "i6mfjfxbgA8FMfnf0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~lever-postings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-lever-postings-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/logiover~lever-postings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-lever-postings-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/logiover~lever-postings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-lever-postings-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "jobs",
                            "jobDetail"
                        ],
                        "type": "string",
                        "description": "What to fetch: a list of jobs from one or more Lever sites, or a deep detail object for specific posting IDs.",
                        "default": "jobs"
                    },
                    "sites": {
                        "title": "Lever sites",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more Lever site names. For 'jobDetail' mode only the first site is used. Case-sensitive. Try 'leverdemo' for a guaranteed-working smoke test.",
                        "default": [
                            "leverdemo"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "instance": {
                        "title": "Instance",
                        "enum": [
                            "global",
                            "eu"
                        ],
                        "type": "string",
                        "description": "Lever runs two regional instances. Most companies are on 'global' (api.lever.co). EU customers (frequent for European-only employers) are on 'eu' (api.eu.lever.co). If you get 404s on 'global', try 'eu'.",
                        "default": "global"
                    },
                    "jobIds": {
                        "title": "Job IDs (jobDetail mode only)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of posting UUIDs to fetch. Required when mode = jobDetail. Example: 5ac21346-8e0c-4494-8e7a-3eb92ff77902",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "team": {
                        "title": "Team (server-side filter)",
                        "type": "array",
                        "description": "Lever-native filter. Postings are filtered server-side. Case-sensitive — must match exactly (e.g. 'Engineering' not 'engineering'). Multiple values are OR'ed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "department": {
                        "title": "Department (server-side filter)",
                        "type": "array",
                        "description": "Lever-native filter. Case-sensitive. Multiple values are OR'ed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location (server-side filter)",
                        "type": "array",
                        "description": "Lever-native filter. Case-sensitive. Multiple values are OR'ed. Example: 'San Francisco' or 'Remote - US'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "commitment": {
                        "title": "Commitment / employment type (server-side filter)",
                        "type": "array",
                        "description": "Lever-native filter. Case-sensitive. Examples: 'Full Time', 'Part Time', 'Internship', 'Contract'. Multiple values are OR'ed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "level": {
                        "title": "Level (server-side filter)",
                        "type": "array",
                        "description": "Lever-native filter. Case-sensitive. Values are customer-defined (e.g. 'Senior', 'Junior', 'Director').",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Lever native limit (per site)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Forwarded as Lever's ?limit= parameter. Caps the number of postings the server returns per board. Leave at 0 for no cap.",
                        "default": 0
                    },
                    "skip": {
                        "title": "Lever native skip (per site)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Forwarded as Lever's ?skip= parameter. Use for pagination: skip N postings from the start before returning results.",
                        "default": 0
                    },
                    "group": {
                        "title": "Group results (Lever native)",
                        "enum": [
                            "none",
                            "team",
                            "commitment",
                            "location"
                        ],
                        "type": "string",
                        "description": "Lever's ?group= parameter. When set, the API returns postings grouped by the chosen category. Leave as 'none' for ungrouped output.",
                        "default": "none"
                    },
                    "filterTitleKeywords": {
                        "title": "Title contains keywords",
                        "type": "array",
                        "description": "Client-side: keep only postings whose title contains any of these strings (case-insensitive). Useful for job-role targeting (e.g. 'engineer', 'designer'). Multiple keywords are OR'ed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "filterWorkplaceTypes": {
                        "title": "Workplace type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Client-side: keep only postings with these workplace types. Lever's native enum values.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "on-site",
                                "remote",
                                "hybrid",
                                "unspecified"
                            ]
                        },
                        "default": []
                    },
                    "filterCountries": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "Client-side: keep only postings whose 'country' field matches one of these ISO 3166-1 alpha-2 codes (e.g. 'US', 'GB', 'DE'). Case-insensitive.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "filterSalaryMin": {
                        "title": "Minimum disclosed salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Client-side: keep only postings whose salaryRange.min is >= this number. Postings WITHOUT a disclosed salary are dropped when this filter is active. Set to 0 to disable.",
                        "default": 0
                    },
                    "maxResultsPerSite": {
                        "title": "Max results per site (final cap)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap applied after all filters. 0 = unlimited. Useful for testing or controlling cost."
                    },
                    "concurrency": {
                        "title": "Parallel sites",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many sites to fetch in parallel. 5 is a safe default. Higher = faster, but Lever may rate-limit you on huge batches.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
