# JobDataLake — Enriched Job Listings API (20,000+ Companies) (`gifted_allergy/jobdatalake-job-search`) Actor

Search 1M+ enriched job listings from 20,000+ company career pages. Filter by skills, salary, remote type, seniority, and more. Powered by the JobDataLake API.

- **URL**: https://apify.com/gifted\_allergy/jobdatalake-job-search.md
- **Developed by:** [Morgan Gao](https://apify.com/gifted_allergy) (community)
- **Categories:** Jobs, Developer tools, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## JobDataLake — Enriched Job Listings API

**Search 1,000,000+ enriched job listings** from 20,000+ company career pages. Get structured, AI-enriched job data with salary, skills, seniority, remote policy, and more — without building your own scrapers.

This Actor wraps the [JobDataLake API](https://www.jobdatalake.com), making it easy to query enriched job data directly from the Apify platform. Use it standalone, via the Apify API, or as an MCP tool in AI agents like Claude and Cursor.

### Why JobDataLake?

- **1M+ jobs** from 20,000+ companies, updated hourly
- **AI-enriched fields** — salary (normalized to USD), required skills, seniority, remote policy, job function, education requirements
- **Sub-100ms responses** — powered by Typesense search
- **Clean JSON schema** — no nested junk, every field documented
- **Semantic search** — describe your ideal role in plain English (remote + tech jobs)

Unlike raw job scrapers, JDL gives you pre-normalized, enriched data ready for analysis, apps, or AI pipelines. No HTML parsing, no deduplication, no data cleaning required.

### How to use this Actor

1. **Get a free JDL API key** at [jobdatalake.com](https://www.jobdatalake.com) (1,000 free credits included)
2. Open this Actor on Apify and click **Start**
3. Paste your API key and enter a search query
4. Run the Actor and download results as JSON, CSV, or Excel

Each API request costs 1 JDL credit. A search returning 100 jobs on one page = 1 credit. Pagination costs 1 credit per page.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `jdlApiKey` | string | Yes | Your JDL API key ([get one free](https://www.jobdatalake.com)) |
| `query` | string | No | Search query (default: `*` for all jobs) |
| `location` | string | No | Location filter (e.g. "Remote", "San Francisco") |
| `remoteType` | string | No | `fully_remote`, `hybrid`, or `on_site` |
| `seniority` | string | No | Comma-separated: `junior`, `senior`, `staff`, etc. |
| `skills` | string | No | Required skills filter (e.g. "Python,AWS") |
| `salaryMin` | integer | No | Minimum annual salary in USD |
| `jobFunction` | string | No | `eng`, `data`, `design`, `sales`, `product`, etc. |
| `domain` | string | No | Company domain (e.g. "stripe.com") |
| `limit` | integer | No | Max results (default: 100, max: 10,000) |

### Output

Each job in the dataset includes:

```json
{
    "title": "Senior Backend Engineer",
    "company_name": "Stripe",
    "domain_name": "stripe.com",
    "posted_at": 1775520869,
    "locations": ["San Francisco, CA", "Remote"],
    "countries": ["US"],
    "remote_type": "fully_remote",
    "job_function": "eng",
    "seniority": ["Senior"],
    "salary_min_usd": 180000,
    "salary_max_usd": 250000,
    "required_skills": ["Python", "AWS", "Kubernetes", "Go"],
    "employment_type": "full_time",
    "url": "https://stripe.com/jobs/listing/senior-backend-engineer/...",
    "job_handle": "stripe-senior-backend-engineer-remote-abc123"
}
````

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data fields

| Field | Description |
|-------|-------------|
| `title` | Job title |
| `company_name` | Company name |
| `domain_name` | Company website domain |
| `posted_at` | Unix timestamp when job was posted |
| `locations` | Array of work locations |
| `countries` | ISO country codes |
| `remote_type` | `fully_remote`, `hybrid`, or `on_site` |
| `job_function` | Department: `eng`, `data`, `design`, `sales`, etc. |
| `seniority` | Array: `junior`, `mid`, `senior`, `staff`, `principal` |
| `salary_min_usd` | Annual minimum salary (USD) |
| `salary_max_usd` | Annual maximum salary (USD) |
| `required_skills` | Array of required skills |
| `employment_type` | `full_time`, `part_time`, `contract`, `internship` |
| `url` | Direct apply link |
| `job_handle` | Unique job identifier/slug |

### Pricing

- **Apify charges** for compute time (Actor runtime). Typical runs cost < $0.01.
- **JDL charges** credits per API request against your JDL plan:
  - Free: 1,000 credits
  - Starter: 1,000,000 credits — $200
  - Growth: 2,000,000 credits — $300
  - Business: 4,000,000 credits — $400

Credits never expire. [Get your API key](https://www.jobdatalake.com).

### Tips

- Use `per_page` wisely: fetching 100 jobs per page costs 1 credit. Fetching 1 job per page also costs 1 credit.
- Set `limit` to control costs — start small and increase once you've validated the data format.
- Use `skills` filter for precise results: `skills=Python,Kubernetes` returns only jobs requiring both.
- Use `remoteType=fully_remote` for remote-only results.

### FAQ

**Is this a web scraper?**
No. This Actor calls the JobDataLake REST API, which aggregates and enriches job data from 20,000+ company career pages. No scraping happens inside this Actor.

**Do I need an Apify subscription?**
The Apify free tier is sufficient for most use cases. You do need a [JDL API key](https://www.jobdatalake.com) (free tier: 1,000 credits).

**Can I use this with Claude, Cursor, or other AI tools?**
Yes! Apify Actors are automatically available as MCP tools. Connect the Apify MCP server to your AI tool and use this Actor as a function call.

**How fresh is the data?**
Jobs are scraped from company career pages and updated hourly. New postings are typically indexed within 3 hours.

### Support

For issues with this Actor, open an issue in the Issues tab.
For JDL API questions, contact mg@jobdatalake.com.
For Apify platform issues, visit [apify.com/support](https://apify.com/support).

# Actor input Schema

## `jdlApiKey` (type: `string`):

Your JobDataLake API key. Get one free at https://www.jobdatalake.com (1,000 free credits).

## `query` (type: `string`):

Keyword search (e.g. 'backend engineer', 'React', 'data scientist'). Use \* for all jobs.

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

Free-text location filter (e.g. 'Remote', 'San Francisco', 'London').

## `remoteType` (type: `string`):

Filter by remote work policy.

## `seniority` (type: `string`):

Filter by seniority level (comma-separated).

## `skills` (type: `string`):

Filter by required skills (comma-separated, e.g. 'Python,AWS,Kubernetes').

## `salaryMin` (type: `integer`):

Minimum annual salary in USD.

## `jobFunction` (type: `string`):

Filter by department/function.

## `domain` (type: `string`):

Filter by company domain (e.g. 'stripe.com').

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

Maximum number of jobs to return (max 10,000). Each result costs 1 JDL credit.

## Actor input object example

```json
{
  "query": "backend engineer",
  "remoteType": "",
  "jobFunction": "",
  "limit": 100
}
```

# Actor output Schema

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

No description

# 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 = {
    "query": "backend engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("gifted_allergy/jobdatalake-job-search").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 = { "query": "backend engineer" }

# Run the Actor and wait for it to finish
run = client.actor("gifted_allergy/jobdatalake-job-search").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 '{
  "query": "backend engineer"
}' |
apify call gifted_allergy/jobdatalake-job-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=gifted_allergy/jobdatalake-job-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JobDataLake — Enriched Job Listings API (20,000+ Companies)",
        "description": "Search 1M+ enriched job listings from 20,000+ company career pages. Filter by skills, salary, remote type, seniority, and more. Powered by the JobDataLake API.",
        "version": "1.0",
        "x-build-id": "abS4dW1M1zmwfYY2Z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gifted_allergy~jobdatalake-job-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gifted_allergy-jobdatalake-job-search",
                "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/gifted_allergy~jobdatalake-job-search/runs": {
            "post": {
                "operationId": "runs-sync-gifted_allergy-jobdatalake-job-search",
                "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/gifted_allergy~jobdatalake-job-search/run-sync": {
            "post": {
                "operationId": "run-sync-gifted_allergy-jobdatalake-job-search",
                "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": [
                    "jdlApiKey"
                ],
                "properties": {
                    "jdlApiKey": {
                        "title": "JDL API Key",
                        "type": "string",
                        "description": "Your JobDataLake API key. Get one free at https://www.jobdatalake.com (1,000 free credits)."
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword search (e.g. 'backend engineer', 'React', 'data scientist'). Use * for all jobs.",
                        "default": "*"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Free-text location filter (e.g. 'Remote', 'San Francisco', 'London')."
                    },
                    "remoteType": {
                        "title": "Remote Type",
                        "enum": [
                            "",
                            "fully_remote",
                            "hybrid",
                            "on_site"
                        ],
                        "type": "string",
                        "description": "Filter by remote work policy.",
                        "default": ""
                    },
                    "seniority": {
                        "title": "Seniority",
                        "type": "string",
                        "description": "Filter by seniority level (comma-separated)."
                    },
                    "skills": {
                        "title": "Skills",
                        "type": "string",
                        "description": "Filter by required skills (comma-separated, e.g. 'Python,AWS,Kubernetes')."
                    },
                    "salaryMin": {
                        "title": "Minimum Salary (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum annual salary in USD."
                    },
                    "jobFunction": {
                        "title": "Job Function",
                        "enum": [
                            "",
                            "eng",
                            "data",
                            "design",
                            "sales",
                            "ops",
                            "marketing",
                            "security",
                            "product",
                            "finance",
                            "hr",
                            "legal",
                            "other"
                        ],
                        "type": "string",
                        "description": "Filter by department/function.",
                        "default": ""
                    },
                    "domain": {
                        "title": "Company Domain",
                        "type": "string",
                        "description": "Filter by company domain (e.g. 'stripe.com')."
                    },
                    "limit": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of jobs to return (max 10,000). Each result costs 1 JDL credit.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
