Pricing

from $2.00 / 1,000 results

Lever Job Scraper & API

Scrape Lever ATS jobs via API with department and team filtering. Pull live roles from thousands of Lever-hosted career sites. Built for job boards and AI agents.

Pricing

from $2.00 / 1,000 results

Rating

0.0

(0)

Developer

Damien Alleyne

Actor stats

Bookmarked

Total users

Monthly active users

15 hours ago

Last modified

.gitignore

node_modules/
apify_storage/
storage/
dist/
.env
.DS_Store
*.log
.apify/

Dockerfile

FROM apify/actor-node:22

COPY package*.json ./

RUN npm --quiet set progress=false \
 && npm install --only=prod --no-optional \
 && echo "Installed NPM packages:" \
 && (npm list --only=prod --no-optional --all || true) \
 && echo "Node.js version:" \
 && node --version \
 && echo "NPM version:" \
 && npm --version

COPY . ./

CMD npm start

LICENSE

MIT License

Copyright (c) 2026 Damien Alleyne

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

package.json

{
  "name": "lever-job-scraper",
  "version": "1.1.3",
  "description": "Open source Lever Job Scraper with department, team, and recency filtering",
  "type": "module",
  "main": "src/main.js",
  "scripts": {
    "start": "node src/main.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "apify",
    "lever",
    "jobs",
    "scraper",
    "ats",
    "department-filter"
  ],
  "author": "Damien Alleyne <damien@alleyne.dev>",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/d-alleyne/lever-job-scraper.git"
  },
  "dependencies": {
    "apify": "^3.5.3"
  }
}

.actor/INPUT_SCHEMA.json

{
    "title": "Lever Job Scraper Input",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "urls": {
            "title": "Job Board URLs",
            "type": "array",
            "description": "Lever job board URLs to scrape. Each entry can be a plain URL string, or an object with a required `url` plus optional per-board filters (use the JSON tab): `departments` (array of department name strings to keep, case-insensitive, filtered before storing), `teams` (array of team name strings), `maxJobs` (integer cap per board), `daysBack` (integer; only jobs created in the last N days). Example: {\"url\": \"https://jobs.lever.co/anchorage\", \"departments\": [\"Engineering\"], \"teams\": [\"Blockchain\"], \"maxJobs\": 20, \"daysBack\": 7}. Unlike Greenhouse, department and team are plain names, so no ID lookup is needed.",
            "editor": "requestListSources",
            "placeholderKey": "url",
            "placeholderValue": "https://jobs.lever.co/anchorage",
            "patternKey": "url",
            "patternValue": "https://jobs(\\.eu)?\\.lever\\.co/.+",
            "prefill": [
                {
                    "url": "https://jobs.lever.co/mistral"
                },
                {
                    "url": "https://jobs.lever.co/anchorage",
                    "departments": ["Engineering"],
                    "teams": ["Blockchain"],
                    "maxJobs": 25,
                    "daysBack": 30
                }
            ]
        }
    },
    "required": ["urls"]
}

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "lever-job-scraper",
    "title": "Lever Job Scraper & API",
    "description": "Scrape Lever ATS jobs via API with department and team filtering. Pull live roles from thousands of Lever-hosted career sites. Built for job boards and AI agents.",
    "version": "1.0",
    "license": "MIT",
    "dockerfile": "./Dockerfile",
    "readme": "./README.md",
    "categories": ["JOBS"],
    "input": "./INPUT_SCHEMA.json",
    "output": "./output_schema.json",
    "storages": {
        "dataset": {
            "actorSpecification": 1,
            "title": "Lever Job Listings",
            "views": {
                "overview": {
                    "title": "Overview",
                    "transformation": {
                        "fields": [
                            "title",
                            "company",
                            "department",
                            "team",
                            "location",
                            "type",
                            "salary",
                            "publishedAt",
                            "postingUrl"
                        ]
                    },
                    "display": {
                        "component": "table",
                        "properties": {
                            "title": { "label": "Job Title", "format": "text" },
                            "company": { "label": "Company", "format": "text" },
                            "department": { "label": "Department", "format": "text" },
                            "team": { "label": "Team", "format": "text" },
                            "location": { "label": "Location", "format": "text" },
                            "type": { "label": "Type", "format": "text" },
                            "salary": { "label": "Salary", "format": "object" },
                            "publishedAt": { "label": "Created", "format": "date" },
                            "postingUrl": { "label": "URL", "format": "link" }
                        }
                    }
                }
            }
        }
    }
}

.actor/output_schema.json

{
  "actorOutputSchemaVersion": 1,
  "title": "Lever Job Scraper Output",
  "description": "Scraped job listings from Lever job boards with enhanced data extraction",
  "properties": {
    "jobs": {
      "type": "string",
      "title": "Job Listings",
      "description": "All scraped job postings with departments, teams, salaries, locations, and metadata",
      "template": "{{links.apiDefaultDatasetUrl}}/items"
    }
  }
}

assets/lever-actor-icon.png

assets/lever-actor-icon.svg

1<svg width="256" height="256" viewBox="0 0 256 256" xmlns="http://www.w3.org/2000/svg">
2  <defs>
3    <linearGradient id="bg" x1="0" y1="0" x2="0" y2="1">
4      <stop offset="0" stop-color="#FF7A4D"/>
5      <stop offset="1" stop-color="#C73E22"/>
6    </linearGradient>
7  </defs>
8  <rect x="0" y="0" width="256" height="256" rx="52" fill="url(#bg)"/>
9
10  <!-- Lever: a bar balanced on a triangular fulcrum -->
11  <path d="M118 124 L94 162 L142 162 Z" fill="#FFFFFF"/>
12  <line x1="54" y1="152" x2="186" y2="90" stroke="#FFFFFF" stroke-width="18" stroke-linecap="round"/>
13
14  <!-- Magnifying glass (shared scraper motif), bottom-right -->
15  <circle cx="184" cy="180" r="30" fill="#5E1A0E"/>
16  <circle cx="184" cy="180" r="30" fill="none" stroke="#FFFFFF" stroke-width="16"/>
17  <line x1="205" y1="201" x2="227" y2="223" stroke="#FFFFFF" stroke-width="16" stroke-linecap="round"/>
18</svg>

src/main.js

1import { Actor } from 'apify';
2
3/**
4 * Extract the company/site token from a Lever job board URL.
5 * Handles jobs.lever.co/{site} and the EU host jobs.eu.lever.co/{site}.
6 * @param {string} url
7 * @returns {string|null} site token or null if invalid
8 */
9function extractCompanyName(url) {
10    const match = url.match(/lever\.co\/([^\/\?]+)/);
11    return match ? match[1] : null;
12}
13
14/**
15 * Fetch all public postings for a Lever site in one call.
16 * mode=json returns full posting objects including descriptions, so unlike
17 * Greenhouse/Ashby there is no per-job detail fetch.
18 * @param {string} site
19 * @returns {Promise<Array>} array of Lever posting objects
20 */
21async function fetchPostings(site) {
22    const apiUrl = `https://api.lever.co/v0/postings/${site}?mode=json`;
23    const response = await fetch(apiUrl, { headers: { Accept: 'application/json' }, signal: AbortSignal.timeout(30_000) });
24    if (!response.ok) {
25        throw new Error(`API request failed: ${response.status} ${response.statusText}`);
26    }
27    const data = await response.json();
28    if (!Array.isArray(data)) {
29        throw new Error(`Unexpected Lever response (not an array): ${JSON.stringify(data).slice(0, 200)}`);
30    }
31    return data;
32}
33
34/** Normalize a date to ISO 8601, or null if missing/invalid (never throws).
35 *  Lever's API sends createdAt as epoch milliseconds (a number), which Date.parse can't read. */
36function toIso(s) {
37    if (!s) return null;
38    const t = typeof s === 'number' ? s : Date.parse(s);
39    return Number.isNaN(t) ? null : new Date(t).toISOString();
40}
41
42/**
43 * Case-insensitive membership test against a filter list.
44 * Empty/absent filter list means "keep everything".
45 * @param {string|null|undefined} value
46 * @param {Array<string>} filters
47 * @returns {boolean}
48 */
49function passesFilter(value, filters) {
50    if (!filters || filters.length === 0) return true;
51    if (!value) return false;
52    const v = String(value).toLowerCase().trim();
53    return filters.some((f) => String(f).toLowerCase().trim() === v);
54}
55
56/**
57 * Regex salary parser for free-text descriptions, used only when Lever has no
58 * structured salaryRange. Handles $80k-$120k, $80,000-$120,000, £50k-£70k, €60k-€80k.
59 * @param {string} text
60 * @returns {{min:number,max:number,currency:string,raw:string}|null}
61 */
62function parseSalaryFromText(text) {
63    const salaryMatch = (text || '').match(
64        /([£€$])(\d{1,3}(?:,\d{3})*|\d+)[kK]?\s*[-–]\s*\1(\d{1,3}(?:,\d{3})*|\d+)[kK]?/,
65    );
66    if (!salaryMatch) return null;
67
68    const parseAmount = (str) => {
69        const num = parseInt(str.replace(/,/g, ''), 10);
70        // Only scale by 1000 when the matched token actually carries a 'k'.
71        return /[kK]/.test(str) ? num * 1000 : num;
72    };
73
74    let currency = salaryMatch[1] === '£' ? 'GBP' : salaryMatch[1] === '€' ? 'EUR' : 'USD';
75    if (salaryMatch[1] === '$') {
76        const matchIndex = text.indexOf(salaryMatch[0]);
77        const context = text.slice(Math.max(0, matchIndex - 200), matchIndex + 200);
78        if (/\bCAD\b|Canada/i.test(context)) currency = 'CAD';
79        else if (/\bAUD\b|Australia/i.test(context)) currency = 'AUD';
80        else if (/\bEUR\b|Europe|Ireland/i.test(context)) currency = 'EUR';
81        else if (/\bGBP\b|UK|United Kingdom/i.test(context)) currency = 'GBP';
82    }
83
84    return {
85        min: parseAmount(salaryMatch[2]),
86        max: parseAmount(salaryMatch[3]),
87        currency,
88        interval: null,
89        raw: salaryMatch[0],
90    };
91}
92
93/**
94 * Build salary object: prefer Lever's structured salaryRange, fall back to regex.
95 * @param {Object} posting
96 * @returns {Object|null}
97 */
98function extractSalary(posting) {
99    const sr = posting.salaryRange;
100    if (sr && (sr.min != null || sr.max != null)) {
101        return {
102            min: sr.min != null ? Number(sr.min) : null,
103            max: sr.max != null ? Number(sr.max) : null,
104            currency: sr.currency || 'USD',
105            interval: sr.interval || null,
106            raw: `${sr.currency || ''}${sr.min ?? ''}-${sr.max ?? ''}`.trim(),
107        };
108    }
109    // No structured range: parse the dedicated salary blurb or plain-text description (never raw HTML).
110    return parseSalaryFromText(posting.salaryDescriptionPlain || posting.descriptionPlain || '');
111}
112
113/**
114 * Map a raw Lever posting to the standardized output shape (kept consistent with
115 * the Greenhouse and Ashby actors).
116 * @param {Object} posting
117 * @param {string} site
118 * @returns {Object}
119 */
120function formatJobOutput(posting, site) {
121    const categories = posting.categories || {};
122    const locationRaw = categories.location || '';
123    const locations = Array.isArray(categories.allLocations) && categories.allLocations.length
124        ? categories.allLocations
125        : (locationRaw ? [locationRaw] : []);
126
127    const workplaceType = posting.workplaceType || null; // 'remote' | 'on-site' | 'hybrid' | 'unspecified'
128    // Lever often encodes the work model in `commitment` (e.g. "Full-Time - Hybrid"), so include it.
129    const haystack = `${workplaceType || ''} ${categories.commitment || ''} ${locations.join(' ')}`.toLowerCase();
130    const isRemote = workplaceType === 'remote' || haystack.includes('remote');
131    const isHybrid = workplaceType === 'hybrid' || haystack.includes('hybrid');
132
133    return {
134        id: posting.id,
135        company: site,
136        type: categories.commitment || null,
137        title: posting.text,
138        description: posting.description || '',
139        descriptionPlain: posting.descriptionPlain || '',
140
141        location: locationRaw,
142        locations,
143        workplaceType,
144        isRemote,
145        isHybrid,
146
147        salary: extractSalary(posting),
148        salaryDescription: posting.salaryDescriptionPlain || null,
149
150        department: categories.department || null,
151        team: categories.team || null,
152        country: posting.country || null,
153
154        metadata: {
155            commitment: categories.commitment || null,
156            department: categories.department || null,
157            team: categories.team || null,
158        },
159
160        postingUrl: posting.hostedUrl || `https://jobs.lever.co/${site}/${posting.id}`,
161        applyUrl: posting.applyUrl || `${posting.hostedUrl || `https://jobs.lever.co/${site}/${posting.id}`}/apply`,
162        publishedAt: toIso(posting.createdAt),
163    };
164}
165
166await Actor.main(async () => {
167    const input = await Actor.getInput() || {};
168    const urls = input.urls || input.requestListSources || [];
169
170    if (!urls || urls.length === 0) {
171        throw new Error('No URLs provided. Add at least one Lever job board URL to the "urls" field.');
172    }
173
174    let totalProcessed = 0;
175    let boardErrors = 0;
176
177    for (const urlConfig of urls) {
178        const url = typeof urlConfig === 'string' ? urlConfig : urlConfig.url;
179        const departments = (urlConfig && urlConfig.departments) || [];
180        const teams = (urlConfig && urlConfig.teams) || [];
181        const maxJobs = (urlConfig && urlConfig.maxJobs) || null;
182        const daysBack = (urlConfig && urlConfig.daysBack) || null;
183
184        const site = extractCompanyName(url);
185        if (!site) {
186            console.log(`⚠️  Invalid Lever URL: ${url} (expected https://jobs.lever.co/company-name)`);
187            boardErrors++;
188            continue;
189        }
190
191        // Compute date cutoff once per board. Lever exposes createdAt only, so daysBack
192        // means "jobs created in the last N days" — ideal for incremental scheduled runs.
193        let cutoffDate = null;
194        if (daysBack !== null && daysBack !== undefined) {
195            const days = parseInt(daysBack, 10); // coerce so a stringified "7" still works
196            if (Number.isInteger(days) && days > 0) {
197                cutoffDate = new Date();
198                cutoffDate.setDate(cutoffDate.getDate() - days);
199            }
200        }
201
202        console.log(`\n📋 Scraping: ${site}`);
203        if (departments.length) console.log(`   🎯 Department filters: ${departments.join(', ')}`);
204        if (teams.length) console.log(`   🎯 Team filters: ${teams.join(', ')}`);
205        if (cutoffDate) console.log(`   📅 Date filter: created after ${cutoffDate.toISOString()}`);
206
207        try {
208            const postings = await fetchPostings(site);
209            if (!postings.length) {
210                console.log('   ⚠️  No postings found (site may have no active jobs or wrong token)');
211                continue;
212            }
213
214            const boardResults = [];
215            for (const posting of postings) {
216                const categories = posting.categories || {};
217
218                // Filter BEFORE storing so the user is only billed for jobs they keep.
219                if (!passesFilter(categories.department, departments)) continue;
220                if (!passesFilter(categories.team, teams)) continue;
221
222                if (cutoffDate) {
223                    const t = typeof posting.createdAt === 'number'
224                        ? posting.createdAt
225                        : (posting.createdAt ? Date.parse(posting.createdAt) : NaN);
226                    if (Number.isNaN(t) || t < cutoffDate.getTime()) continue; // drop undated/old jobs
227                }
228
229                boardResults.push(formatJobOutput(posting, site));
230
231                if (maxJobs && boardResults.length >= maxJobs) {
232                    console.log(`   Reached maxJobs limit of ${maxJobs}, stopping`);
233                    break;
234                }
235            }
236
237            if (boardResults.length) {
238                await Actor.pushData(boardResults);
239                totalProcessed += boardResults.length;
240            }
241            console.log(`   ✅ Stored ${boardResults.length} job(s) after filtering`);
242        } catch (error) {
243            boardErrors++;
244            console.log(`   ❌ Error scraping ${site}: ${error.message}`);
245        }
246
247        // Small delay to be polite to the API between boards.
248        await new Promise((resolve) => setTimeout(resolve, 100));
249    }
250
251    // Surface total failure: if every board errored and nothing was stored, fail the run.
252    if (boardErrors > 0 && totalProcessed === 0) {
253        throw new Error(`All ${boardErrors} board(s) failed and no jobs were stored.`);
254    }
255
256    console.log(`\n✅ Scraping complete! Stored ${totalProcessed} job(s) from ${urls.length} board(s).`);
257});

Lever Jobs Scraper

fantastic-jobs/lever-jobs-scraper

A simple Lever.co Jobs Scraper with Title, Locations, Description, and Date. Extract job postings from any Lever career page!

Fantastic.jobs

Lever ATS Jobs Scraper – Scrape Lever.co

logiover/lever-postings-scraper

Unofficial Lever.co API: scrape Lever ATS job postings and salary data without an API key, export to CSV/JSON. No login, global + EU instances.

Logiover

Lever.co Jobs Api

fantastic-jobs/lever-co-jobs-api

The perfect Lever Job Scraper API! Direct postings from thousands of company career sites. Enriched with AI and LinkedIn company data, with up to 60 fields per job! Powered by Fantastic.jobs

Fantastic.jobs

Lever Jobs Scraper & API

camiloop96/lever-jobs

Extract all job postings from any Lever career site via the official public API. Fast, no headless browser, no proxies. Clean normalized schema. Ideal for job boards, ATS aggregators, hiring-signal intel and AI agents.

Camilo Polania

Lever ATS Job Scraper

vnx0/lever-ats-job-scraper

Scrape job listings from any company using Lever ATS. Extract titles, descriptions, departments, locations, salary ranges, workplace types, and application links from 5,000+ Lever-powered career pages. Fast JSON API with filtering, deduplication, and bulk multi-company scraping. Get started free.

Vnx0

Lever ATS Jobs Scraper

troy_007/lever-ats-jobs-scraper

Scrape jobs from any company's Lever board via the official API — title, location, team, commitment, remote, description, and apply link.

Pathik Shah

Lever Jobs Scraper & API

jobo.world/lever-jobs-scraper-api

Scrape jobs directly from Lever ATS via one fast API. Pull live roles from VC-backed startups and scale-ups like Lyft, Coinbase & Gusto. Zero ghost jobs, verified daily — built for job boards, AI agents & startup hiring research.

Enrico

115

Lever Jobs Scraper

parseforge/lever-jobs-scraper

Pull every public job posting from one or many Lever ATS company boards. Get title, structured requirements lists, location, work type, salary range, country, hosted URL, and apply URL. Filter by team, department, location, and commitment. Export to JSON, CSV, or Excel for talent intelligence.

ParseForge

Lever Jobs API

aspen-technology-labs-inc/lever-jobs-api

Find job postings from Lever-powered career sites by country, role, company, salary, posting age, employment type, and seniority.

Aspen Technology Labs, Inc.

Lever.co Scraper

lexis-solutions/lever-co-scraper

Scrape job postings from Lever.co-hosted career sites - including titles, locations, departments, posting dates, and application links. Ideal for job aggregation, market analysis, and trend tracking. Fast, structured, and customizable extraction.