# lazee.dev Jobs API

> REST API for 80+ company job boards: filter open tech roles by role, level, country, workplace and ATS. Refreshed every 12 hours. Free plan on RapidAPI.

Canonical: https://lazee.dev/api

=80,all=true;for(var i=0;i

[Back to Home](https://lazee.dev/)
[Live on RapidAPI](https://rapidapi.com/tusharsoni014/api/lazee-dev-jobs-api)

The dataset behind the [lazee.dev job board](https://lazee.dev/careers), over REST and [MCP](https://lazee.dev/mcp-server). Open roles pulled straight from 87 company career sites on Greenhouse, Lever, Ashby, SmartRecruiters, Workday, BambooHR, ClanX, Y Combinator, Superteam and Google Careers, tagged by role, level, country and workplace so you can filter them in one request. Refreshed every 12 hours.

Jobs indexed 33,466

Companies 1,484 From 87 career sites

ATS platforms 10

Refreshed every 12 hours Last 9 hours ago · next in ~5 hours

## Get a key on RapidAPI. Start free.

The Jobs API is sold through RapidAPI. You subscribe there, get your key and are billed there; lazee.dev does not issue keys. The free Basic plan is enough to try every endpoint, and paid plans scale by monthly requests.

Need a field or filter we don't have yet? Tell us and it goes on the list.

[Get your API key](https://rapidapi.com/tusharsoni014/api/lazee-dev-jobs-api) [Request a field or filter](https://lazee.dev/feedback)

On this page

01

## Overview

One read-only REST API, JSON in and out, versioned under `/v1`. It returns the same rows the job board shows: every open role we found on the career sites we track, with the original posting URL. Nothing is user-submitted and nothing is scraped from aggregators; each job comes from the company's own board on its ATS.

- **Filter, don't parse.** Role, level, region and workplace are already worked out from each posting, so a single query like “senior backend, remote, India” needs no text munging on your side.
- **Fresh enough for a job search.** The whole dataset is re-pulled every 12 hours. Closed jobs disappear on the next pull instead of lingering for weeks.
- **Links you can act on.** `url` is the job page on the ATS itself. Every platform listed here is one the lazee.dev extension autofills.

Not included: full job descriptions, salary normalisation, and jobs from boards we do not track yet. See the FAQ.

02

## Data freshness

A scheduled sync runs **every 12 hours**. It fetches every tracked board in full and brings the dataset in line with what the boards list at that moment:

- New postings are added with `first_seen_at` set to the sync time.
- Postings whose title, location, pay or URL changed are rewritten and get a new `synced_at`.
- Postings the board no longer lists are closed: they leave `/jobs`, return 404, and are listed in `/jobs/closed` for 14 days.
- Unchanged postings are left alone, so `synced_at` tells you when a job last actually changed.
- A board that fails to load closes nothing. Its jobs stay as they were, with `source_status: "failed"` and the older `last_checked_at` of the last good read.

Closed job or failed refresh?

Every job carries `last_checked_at`, the last sync that read its board and still found it, and `source_status`, how that board's last sync went. A job is only ever closed when its board loaded and no longer listed it, so a job missing from your next pull is closed exactly when it shows up in `/jobs/closed`. A job with `source_status: "failed"` is unconfirmed, not closed.

GET`/jobs/closed`

Jobs closed in the last 14 days, oldest first. `id` is the id the job had in `/jobs`. `reason` is `closed` (the board stopped listing it), `board_gone` (the company took the whole board down) or `untracked` (we stopped syncing that board). Pass `since` (ISO 8601) with the last `closed_at` you stored, plus `page` and `limit`. A job that reopens comes back in `/jobs` under a new id.

GET /jobs/closed?since=2026-11-10T00:00:00Z · 200 OK

```
{
"data": [
{
"id": "cmh1q7r0b0003pz2m8c5d6e7f",
"platform": "ASHBY",
"company": "Linear",
"title": "Product Designer",
"location": "Remote (US)",
"url": "https://jobs.ashbyhq.com/linear/2b5f1c3e",
"posted_at": "2026-10-02T15:00:00.000Z",
"first_seen_at": "2026-10-03T02:17:00.000Z",
"closed_at": "2026-11-10T14:17:00.000Z",
"reason": "closed"
}
],
"meta": { "page": 1, "limit": 10, "total": 1, "total_pages": 1, "retention_days": 14 }
}
```

GET`/sources`

Every company board we read, with its `status` (`ok`, `failed` or `gone`), job count, last good read and, while it fails, `failing_since`.

GET /sources · 200 OK

```
{
"data": [
{
"platform": "GREENHOUSE",
"company": "Stripe",
"status": "ok",
"job_count": 512,
"last_checked_at": "2026-11-11T02:17:00.000Z",
"last_attempt_at": "2026-11-11T02:17:00.000Z",
"failing_since": null
}
],
"meta": { "total": 1, "ok": 1, "failed": 0, "gone": 0 }
}
```

What that means for your integration

- A job can be up to 12 hours out of date, and a role closed since the last sync may still appear until the next one.
- Polling more often than every 12 hours buys nothing. Cache responses and re-pull when `meta.last_synced_at` changes.
- Use `posted_after` with your last run's `last_synced_at` to pick up only what is new.
- Drop closed jobs from your copy with `/jobs/closed?since=` your last check; pull at least once every 14 days so none age out first.
- `posted_at` is the board's own date when it publishes one. Boards that only show relative dates keep the first value we recorded.
- There are no webhooks yet.

03

## Authentication

Every request carries your RapidAPI key in `X-RapidAPI-Key`and the API's host in `X-RapidAPI-Host`. RapidAPI issues the key when you subscribe and shows both values, ready to copy, on the API's Endpoints tab.

request headers

```
GET https://lazee-dev-jobs-api.p.rapidapi.com/v1/jobs?role=frontend
X-RapidAPI-Key: YOUR_API_KEY
X-RapidAPI-Host: lazee-dev-jobs-api.p.rapidapi.com
Accept: application/json
```

Keys are for server-side use. Do not ship one inside a browser or mobile app; proxy the call through your own backend instead.

04

## Endpoints

Base URL: `https://lazee-dev-jobs-api.p.rapidapi.com/v1`. All endpoints are `GET` and return `application/json`. The full contract is also available as an [OpenAPI 3 spec](https://lazee.dev/api/v1/openapi.json).

[GET`/jobs`  Search and filter jobs. Paginated, newest first.](https://lazee.dev/#list-jobs) [GET`/jobs/{id}`  One job by `id`. 404 once its board takes it down, with `closed` details for 14 days.](https://lazee.dev/#job-object) [GET`/jobs/closed`  Jobs closed in the last 14 days, with when and why.](https://lazee.dev/#freshness) [GET`/sources`  Every company board with how its last sync went.](https://lazee.dev/#freshness) [GET`/filters`  Every accepted value for `role`, `level`, `region`, `workplace` and `platform`, with labels, plus the list of companies.](https://lazee.dev/#filter-values)

GET`/stats`

Dataset size, number of companies and platforms, and the last sync time.

GET /stats · 200 OK

```
{
"data": {
"total_jobs": 1284,
"companies": 87,
"platforms": 10,
"last_synced_at": "2026-10-22T02:00:00.000Z",
"refresh_interval_hours": 12
}
}
```

05

## List and filter jobs

GET`/jobs`

Every parameter is optional and they combine with AND. A parameter that accepts several values matches any of them (OR within the parameter). Unknown parameters are ignored; known parameters with a bad value return 400.

| Parameter | Type | Description | Default |
| --- | --- | --- | --- |
| `q` | string | Free-text search. Case-insensitive match against the job title, company name and location. | — |
| `role` | enum | Role category worked out from the title. One of the role keys below, or `engineering` for every engineering role at once. Comma-separate several keys to match any of them. | — |
| `level` | enum | Experience level. One or more level keys, comma-separated. | — |
| `region` | enum | Country or region the job is in. A job with several offices matches every region it mentions. | — |
| `workplace` | enum | `remote`, `hybrid` or `onsite`. Jobs whose board doesn't say have `null` and never match this filter. | — |
| `platform` | enum | The ATS the job is hosted on. One or more platform keys, comma-separated. | — |
| `company` | string | Exact company name, case-insensitive (for example Stripe). Comma-separate several. | — |
| `has_compensation` | boolean | `true` returns only jobs whose posting lists a pay range. | `false` |
| `salary_min` | number | Yearly pay of at least this, in `salary_currency`: jobs whose pay range reaches it. Other currencies are converted at the day's ECB rate, hourly and monthly pay count as yearly, and jobs that don't list pay never match. `3000000` with `salary_currency=INR` is 30 LPA. | — |
| `salary_max` | number | Yearly pay of at most this, in `salary_currency`: jobs whose range starts at or below it. With `salary_min`, a range. | — |
| `salary_currency` | string | ISO 4217 code of `salary_min` and `salary_max`, for example `USD`, `INR` or `EUR`. | `USD` |
| `posted_after` | date | ISO 8601 date or datetime. Only jobs with `posted_at` on or after this moment. | — |
| `sort` | enum | `posted_desc` (newest first) or `posted_asc`. Ties are broken by `id` so pages never overlap. | `posted_desc` |
| `page` | integer | 1-based page number. | `1` |
| `limit` | integer | Results per page, 1 to 100. | `10` |

Response: an array under `data` plus a `meta` object.

200 OK

```
{
"data":  [/* job objects, see "The job object" */ ],
"meta": {
"page": 1,
"limit": 10,
"total": 1284,
"total_pages": 129,
"last_synced_at": "2026-10-22T02:00:00.000Z"
}
}
```

06

## The job object

GET`/jobs/{id}`

The same object appears in list results and from the single-job endpoint (wrapped in `data`). Field names are `snake_case`; timestamps are ISO 8601 in UTC.

job

```
{
"id": "cmh3k9x2a0001qzk8f1g7h4jd",
"platform": "GREENHOUSE",
"company": "Stripe",
"title": "Backend Engineer, Payments",
"location": "San Francisco, CA / Remote (US)",
"workplace": "remote",
"department": "Engineering",
"employment_type": "Full-time",
"compensation": "$180,000 – $250,000",
"salary": { "min": 180000, "max": 250000, "currency": "USD", "period": "year" },
"url": "https://boards.greenhouse.io/stripe/jobs/1234567",
"posted_at": "2026-10-21T09:15:00.000Z",
"first_seen_at": "2026-10-22T02:00:00.000Z",
"synced_at": "2026-10-22T02:00:00.000Z",
"last_checked_at": "2026-10-23T02:00:00.000Z",
"source_status": "ok",
"role": "backend",
"level": "mid",
"regions": ["us"]
}
```

| Field | Type | Description |
| --- | --- | --- |
| `id` | string | Stable identifier for the job. Survives updates to the posting. |
| `platform` | enum | ATS the job is hosted on. One of the platform keys below. |
| `company` | string | Company name as the board publishes it. |
| `title` | string | Job title as posted. |
| `location` | string \| null | Location text from the board, untouched. Can list several offices. |
| `workplace` | enum \| null | `remote`, `hybrid`, `onsite`, or `null`when the board doesn't say. |
| `department` | string \| null | Board's own department or team label, when it has one. |
| `employment_type` | string \| null | Full-time, Contract, Internship and so on, as the board words it. |
| `compensation` | string \| null | Pay range exactly as the posting shows it. |
| `salary` | object \| null | `compensation` read as numbers: `min` and `max`per year in the job's own `currency`(either can be null, as in "up to $180K"), and the `period` the posting wrote it in. Null when it names no amount. |
| `url` | string | The job page on the ATS itself. Apply there; the lazee.dev extension autofills it. |
| `posted_at` | datetime | The board's posted date. When a board has none, the moment we first saw the job. |
| `first_seen_at` | datetime | When the job first appeared in a sync. |
| `synced_at` | datetime | The last sync that added or changed this job. Unchanged jobs keep their earlier value. |
| `last_checked_at` | datetime \| null | The last sync that read the job's board and found the job still listed. Moves every sync, changed or not. |
| `source_status` | enum \| null | How the last sync of the job's board went: `ok`, or `failed`when the board didn't load and the job is kept as it was at `last_checked_at`. |
| `role` | enum \| null | Role key from the title and department. null for roles outside the list (finance, legal, recruiting). |
| `level` | enum | Level key from the title. Titles with no level cue are classed mid. |
| `regions` | string | Every region key the location mentions. Empty when none is recognised. |

07

## Filter values

GET`/filters`

These are the keys the filters accept today, generated from the same taxonomy the job board uses. Fetch `/filters` at runtime rather than hard-coding them; new keys may be added, existing ones are not renamed within `/v1`.

### param role

Plus `engineering`, a shortcut for every key in the Engineering group.

Engineering

- `software`Software engineering
- `frontend`Frontend
- `backend`Backend
- `fullstack`Full stack
- `mobile`Mobile
- `ai-ml`AI / ML
- `data`Data
- `devops`DevOps & infrastructure
- `security`Security
- `qa`QA & testing
- `hardware`Hardware & embedded

Business

- `product`Product & program
- `design`Design
- `sales`Sales
- `marketing`Marketing & growth
- `support`Customer success & solutions

### param level

- `intern`Internship
- `entry`Entry level
- `mid`Mid level
- `senior`Senior
- `staff`Staff & principal
- `manager`Manager & above

### param region

- `us`United States
- `india`India
- `canada`Canada
- `uk`United Kingdom
- `europe`Europe
- `singapore`Singapore
- `japan`Japan
- `asia`Asia (other)
- `australia`Australia & NZ
- `latam`Latin America
- `middle-east`Middle East

### param workplace

- `remote`Remote
- `hybrid`Hybrid
- `onsite`On-site

### param platform

- `GREENHOUSE`Greenhouse
- `LEVER`Lever
- `ASHBY`Ashby
- `SMARTRECRUITERS`SmartRecruiters
- `WORKDAY`Workday
- `BAMBOOHR`BambooHR
- `CLANX`ClanX
- `YCOMBINATOR`Y Combinator
- `SUPERTEAM`Superteam
- `GOOGLE`Google Careers

200 OK

```
{
"data": {
"role":      [{ "key": "backend", "label": "Backend" }, ...],
"level":     [{ "key": "senior", "label": "Senior" }, ...],
"region":    [{ "key": "india", "label": "India" }, ...],
"workplace": [{ "key": "remote", "label": "Remote" }, ...],
"platform":  [{ "key": "GREENHOUSE", "label": "Greenhouse" }, ...],
"company":   ["Airbnb", "Anthropic", "Stripe", ...]
}
}
```

08

## Pagination

Results are paged with `page` and `limit`. The default page size is 10 and the maximum is 100. `meta.total` is the number of jobs matching your filters and `meta.total_pages` is the last page you can request; asking for a page past it returns an empty `data` array, not an error.

Ordering is by `posted_at` then `id`, so paging through a result set between two syncs is stable. A sync in the middle of a long crawl can shift rows; compare `meta.last_synced_at` across pages and restart if it changed.

09

## Errors

Errors use standard HTTP status codes and a JSON body with a machine-readable `code` and a human message. Validation errors also name the offending `param`.

400 Bad Request

```
HTTP/1.1 400 Bad Request
Content-Type: application/json

{
"error": {
"code": "invalid_parameter",
"message": "level must be one of: intern, entry, mid, senior, staff, manager",
"param": "level"
}
}
```

| Status | code | Meaning |
| --- | --- | --- |
| 400 | `invalid_parameter` | A query parameter has a value outside its allowed set or format. The response names the parameter. |
| 401 / 403 | `—` | The RapidAPI key is missing or invalid, or you are not subscribed. Sent by RapidAPI with its own message body. |
| 404 | `not_found` | No job with that id. Jobs taken down by their board are deleted on the next sync and 404 afterwards. |
| 429 | `—` | Over your plan's rate limit or quota. Sent by RapidAPI; back off and retry. |
| 500 | `internal_error` | Something failed on our side. Safe to retry with backoff. |

10

## Rate limits and pricing

Plans, quotas and prices live on the [RapidAPI listing](https://rapidapi.com/tusharsoni014/api/lazee-dev-jobs-api): a free Basic plan for prototyping and paid plans by monthly request volume. RapidAPI enforces rate limits per key and answers `429` when you go over.

Because the data only changes every 12 hours, most integrations need far fewer requests than they first assume. One full pull per sync, filtered to what you need, is usually enough.

Use of the API is subject to the [Jobs API terms](https://lazee.dev/terms#jobs-api).

11

## Examples

Senior backend or full-stack roles, remote, in India:

curl

```
curl "https://lazee-dev-jobs-api.p.rapidapi.com/v1/jobs?role=backend,fullstack&level=senior&region=india&workplace=remote&limit=10" \
-H "X-RapidAPI-Key: YOUR_API_KEY" \
-H "X-RapidAPI-Host: lazee-dev-jobs-api.p.rapidapi.com"
```

Engineering roles mentioning “payments”, posted this month, with a listed pay range:

JavaScript (Node 18+)

```
const params = new URLSearchParams({
q: "payments",
role: "engineering",
has_compensation: "true",
posted_after: "2026-10-01",
limit: "50",
});

const res = await fetch(`https://lazee-dev-jobs-api.p.rapidapi.com/v1/jobs?${params}`, {
headers: {
"X-RapidAPI-Key": process.env.RAPIDAPI_KEY,
"X-RapidAPI-Host": "lazee-dev-jobs-api.p.rapidapi.com",
},
});
if (!res.ok) throw new Error(`Jobs API ${res.status}`);

const { data: jobs, meta } = await res.json();
console.log(`${meta.total} jobs, refreshed ${meta.last_synced_at}`);
for (const job of jobs) console.log(job.company, "—", job.title, job.url);
```

Entry-level and intern roles in the US on Ashby or Lever:

Python (requests)

```
import os, requests

resp = requests.get(
"https://lazee-dev-jobs-api.p.rapidapi.com/v1/jobs",
params={"platform": "ASHBY,LEVER", "level": "entry,intern", "region": "us", "page": 1},
headers={
"X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"],
"X-RapidAPI-Host": "lazee-dev-jobs-api.p.rapidapi.com",
},
timeout=15,
)
resp.raise_for_status()
body = resp.json()

for job in body["data"]:
print(job["company"], "-", job["title"], job["url"])
print("page", body["meta"]["page"], "of", body["meta"]["total_pages"])
```

12

## MCP server

The same data works inside AI apps such as Claude, ChatGPT, Cursor and VS Code, so they can search jobs for you in plain language: “find remote senior backend roles in India posted this week”. There are two ways to connect.

1. lazee.dev MCP server: sign in, no key

Add `https://lazee.dev/mcp` to your AI app and sign in with your lazee.dev account. 100 calls a month free, 5,000 on Pro. In Claude, add it straight from the [connector directory](https://claude.ai/directory/connectors/lazee-dev-jobs). [Setup for each app](https://lazee.dev/mcp-server).

2. RapidAPI's MCP server: your RapidAPI plan, for higher volumes

RapidAPI also serves this API as an MCP server, billed on your RapidAPI plan like any other request, so paid plans take you past the lazee.dev limits. Add this to your client's MCP config (for Claude Desktop, `claude_desktop_config.json`; for Cursor, `.cursor/mcp.json`) and replace `YOUR_RAPIDAPI_KEY` with your key. It needs Node.js 18+ for `npx`.

MCP config (JSON)

```
{
"mcpServers": {
"RapidAPI Hub - lazee.dev Jobs API": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.rapidapi.com",
"--header",
"x-api-host: lazee-dev-jobs-api.p.rapidapi.com",
"--header",
"x-api-key: YOUR_RAPIDAPI_KEY"
]
}
}
}
```

The config holds your key, so keep it out of shared repos.

13

## FAQ

### Where do I get access?

On [RapidAPI](https://rapidapi.com/tusharsoni014/api/lazee-dev-jobs-api), where you subscribe, get a key and pay. Start on the free Basic plan and upgrade when you need more requests.

### Does it include the job description?

Not yet. Each job carries the URL of the original posting, where the description lives. Descriptions are the most requested addition, so tell us if you need them and how you would use them.

### Can I filter by salary?

Yes. `salary_min` and `salary_max` take a yearly amount in `salary_currency`, and match jobs in any currency, converted at the day's ECB rate. Each job's `salary` has its pay as numbers, per year in its own currency. Only jobs that list pay can match (about a fifth of the board), and conversions are approximate. `has_compensation=true`narrows to jobs that list a range at all. Sorting by pay isn't offered.

### How accurate are role, level and region?

They are derived from the title, department and location with rules tuned on the boards we track, not read from a structured field, so a small share of jobs are tagged imperfectly. A title with no level cue is classed `mid`; a role we don't categorise (finance, legal, recruiting) has `role: null`.

### Can you add a company or a board?

Yes, if it is hosted on one of the supported platforms. Send the company's careers URL through the [feedback form](https://lazee.dev/feedback).

### Can I use the job board instead?

You can browse and filter the same dataset for free on the [job board](https://lazee.dev/careers). For programmatic access use the API; please do not scrape the board.

## Related

- [lazee.dev home: the job application autofill extension](https://lazee.dev)
- [Tech job board](https://lazee.dev/careers)
- [Free resume builder](https://lazee.dev/resume-builder)
- [Free ATS resume checker](https://lazee.dev/ats-resume-checker)
- [Free resume screener](https://lazee.dev/resume-screener)
- [Jobs MCP server for AI apps](https://lazee.dev/mcp-server)
- [Blog: guides on applying faster](https://lazee.dev/blog)
- [About lazee.dev](https://lazee.dev/about)
- [Privacy Policy](https://lazee.dev/privacy)
- [Terms of Service](https://lazee.dev/terms)
