# Lever Jobs Scraper: Open Roles, Salaries & Descriptions (`larkmoor/lever-jobs`) Actor

Get every open job from any company's Lever job board (US + EU) via the official public Postings API: title, team, department, all locations, workplace type, salary range, created date, apply link and full description. Filter by keyword, location, team, workplace type, date. $1.25 per 1,000 jobs.

- **URL**: https://apify.com/larkmoor/lever-jobs.md
- **Developed by:** [Larkmoor Data](https://apify.com/larkmoor) (community)
- **Categories:** Jobs, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.06 / 1,000 jobs

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## Lever Jobs Scraper: Open Roles, Salaries & Descriptions

Get every open job from any company that hires through Lever — Palantir, Spotify, and thousands of startups and scale-ups — as clean, structured rows. Give it a list of companies (board names, Lever URLs or just their websites) and get back each job's title, team, department, every location, workplace type (remote / hybrid / on-site), commitment, salary range, created date, apply link and the full description, split into its sections.

It reads Lever's official public Postings API, the endpoint Lever publishes so that job boards and company sites can show their openings. No login, no browser, no proxies, no API key: fast, stable and cheap. Both Lever regions (the global one and the EU one) are checked automatically.

### What you can use it for

- **Job boards and aggregators**: keep a niche board (climate, crypto, AI, remote-only) filled with fresh roles from the companies you track
- **Recruiting and sales intelligence**: see which companies are hiring for which teams, where, and at what pay — a strong buying signal for recruiting agencies and B2B sales
- **Salary research**: Lever stores structured pay ranges (min, max, currency, period) for many US roles because of pay-transparency laws; the actor returns them as numbers, and falls back to a range found in the description
- **Market and competitor research**: track headcount plans by team and location across a list of competitors, week over week
- **Job alerts**: run it on a schedule with "Posted within (days)" = 1 and send new roles to Slack, email or a spreadsheet

### Why this one

- **$1.25 per 1,000 jobs** — about half of what the other Lever scrapers charge, with no monthly rental
- **Any input works**: `palantir`, `https://jobs.lever.co/palantir`, or a company website / careers page that links to its Lever board
- **US and EU boards**: the EU Lever region is tried automatically when a company is not on the global one
- **Structured salary**: Lever's own pay range when the company set one, otherwise a range parsed from the text, with the source marked
- **Sections, not just a blob**: "Responsibilities", "Requirements", "Benefits" and the like come back as lists you can use directly
- **Filters that save money**: keyword, location (city or country code), team, workplace type, employment type, remote-only, date and salary filters run before anything is saved — you only pay for the rows you keep

### Input

| Field | What it does |
|---|---|
| Companies | Lever board slugs (`spotify`), Lever URLs, or company websites |
| Keywords | Keep jobs whose title (or description) mentions any of these |
| Match keywords in title only | Stricter keyword matching |
| Locations | City, region, country code (`US`, `GB`) or `Remote` |
| Teams / departments | e.g. `Engineering`, `Sales` |
| Workplace type | Remote, Hybrid, On-site, Not specified |
| Employment type | e.g. `Full-time`, `Intern`, `Contract` |
| Remote jobs only | Shortcut for remote roles |
| Posted within (days) | Only jobs created in the last N days |
| Only jobs with salary | Skip roles without a pay range |
| Include full description | Turn off for smaller, faster exports |
| Max jobs per company / in total | Hard caps — you never pay for more than this |

Example input:

```json
{
  "companies": ["palantir", "spotify"],
  "keywords": ["engineer"],
  "locations": ["New York", "London"],
  "workplaceTypes": ["hybrid", "onsite"],
  "postedWithinDays": 30,
  "maxResults": 200
}
```

### Output

One row per job:

```json
{
  "company": "spotify",
  "title": "Machine Learning Engineer - Subscriptions",
  "team": "Subscriptions R&D",
  "department": "Engineering",
  "location": "London",
  "allLocations": ["London"],
  "country": "GB",
  "workplaceType": "hybrid",
  "remote": false,
  "employmentType": "Permanent",
  "url": "https://jobs.lever.co/spotify/19c12e29-...",
  "applyUrl": "https://jobs.lever.co/spotify/19c12e29-.../apply",
  "createdAt": "2026-10-23T16:53:57Z",
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "salaryPeriod": null,
  "salarySource": null,
  "sections": [{"heading": "What You'll Do", "items": ["Lead multi-week ML initiatives end to end ..."]}],
  "descriptionText": "At Spotify, our Subscriptions Mission ...",
  "descriptionHtml": "<div>...</div>"
}
```

Download the dataset as JSON, CSV, Excel or XML, or read it through the Apify API.

### How much does it cost?

You pay **$0.00125 per job row** ($1.25 per 1,000) plus a one-time $0.001 per run. Platform compute is tiny because there is no browser: a typical run uses well under one cent of compute.

Worked examples:

1. **One company, everything** — 300 open roles at one large company: 300 × $0.00125 + $0.001 ≈ **$0.38**
2. **Daily alert for 50 companies** — "Posted within 1 day" usually returns 20–80 new roles: about **$0.03–$0.10 per day**
3. **Salary study** — 5,000 US roles with "Only jobs with salary" on: **$6.25**

Rows removed by your filters are never charged. Set "Max jobs in total" to cap any run.

### FAQ

**Is this legal?** The actor reads Lever's public Postings API, which Lever documents for exactly this purpose: publishing a company's open jobs on other sites. It reads only what each company has chosen to post publicly. No login, no personal data about applicants or employees. As always, check that your use of the data fits your local laws and the companies' own terms.

**How do I find a company's Lever name?** Open its careers page; if job links go to `jobs.lever.co/<name>`, that `<name>` is the slug. Or just paste the company website and the actor looks for the link itself.

**Why did a company return 0 jobs?** Either it has no open roles right now, it moved off Lever, or it uses a different job system. The run log says which companies had no board.

**Why is salary empty for some jobs?** Companies set a pay range in Lever only for some roles (mostly US roles in states with pay-transparency laws). When there is none, the actor looks for a range like "$150,000 - $190,000" in the description.

**Can I get jobs from Greenhouse, Ashby or Workday too?** Yes — use our sibling actors for those job systems; the output columns are aligned so you can merge them.

### Tips

- Schedule it daily with "Posted within (days)" = 1 to get only new roles
- Turn off the description for a light CSV with just titles, teams, locations and pay
- Use country codes (`US`, `DE`) in Locations for country-level filtering

### Integrations

Send results to Google Sheets, Slack, Airtable, a webhook, Zapier or Make with Apify integrations, or call the actor from your own code through the Apify API and client libraries.

### Changelog

- **0.1** (October 2026) — first release: US + EU boards, website-to-board detection, structured salary, sections, workplace type and team filters.

# Actor input Schema

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

Lever board slugs (e.g. 'palantir', the part after jobs.lever.co/), Lever job-board URLs, or company websites/careers pages that link to a Lever board. US and EU Lever boards both work.

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

Keep jobs whose title or description contains any of these words (case-insensitive). Empty = all jobs.

## `keywordsInTitleOnly` (type: `boolean`):

Only look for the keywords in the job title (stricter).

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

Keep jobs whose location, any of their locations, or country code contains any of these (e.g. 'New York', 'London', 'US', 'Remote').

## `teams` (type: `array`):

Keep jobs whose team or department contains any of these (e.g. 'Engineering', 'Sales').

## `workplaceTypes` (type: `array`):

Keep only these workplace types as set by the company in Lever. Empty = all.

## `employmentTypes` (type: `array`):

Keep jobs whose commitment contains any of these (e.g. 'Full-time', 'Intern', 'Contract').

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

Keep only remote jobs (Lever workplace type 'remote', or 'remote' in the location or title).

## `postedWithinDays` (type: `integer`):

Keep only jobs created in the last N days. Empty = any age.

## `withSalaryOnly` (type: `boolean`):

Keep only jobs with a salary range (Lever's own pay range, or one found in the description).

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

Include the job description as plain text and HTML.

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

Stop after this many jobs from one company.

## `maxResults` (type: `integer`):

Hard cap on rows for the whole run (you pay per job row).

## Actor input object example

```json
{
  "companies": [
    "palantir",
    "spotify"
  ],
  "keywords": [
    "engineer"
  ],
  "keywordsInTitleOnly": false,
  "remoteOnly": false,
  "withSalaryOnly": false,
  "includeDescription": true,
  "maxJobsPerCompany": 1000,
  "maxResults": 50
}
```

# Actor output Schema

## `results` (type: `string`):

All results as JSON items in the run's default dataset (also downloadable as CSV/Excel from the dataset).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "palantir",
        "spotify"
    ],
    "keywords": [
        "engineer"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("larkmoor/lever-jobs").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": [
        "palantir",
        "spotify",
    ],
    "keywords": ["engineer"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("larkmoor/lever-jobs").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "palantir",
    "spotify"
  ],
  "keywords": [
    "engineer"
  ],
  "maxResults": 50
}' |
apify call larkmoor/lever-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,larkmoor/lever-jobs"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ByEu71UamYfeLIGiW/builds/LRnhF3CUi7DZ4dKkW/openapi.json