# Jobs Data Feed API - Global Job Postings, Salaries & Skills (`nabeelbaghoor/jobs-data-feed-api`) Actor

Search a global feed of aggregated job postings from thousands of boards and career sites. Export structured listings - title, company, location, salary, category, job type, skills and seniority - filtered by keyword, company, location and date. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/jobs-data-feed-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Jobs, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$12.00 / 1,000 job 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Jobs Data Feed API - global job postings, salaries and skills

**Jobs Data Feed API** turns a worldwide feed of aggregated job postings into a clean, structured dataset. Search millions of listings crawled from thousands of job boards and company career sites, and export every match - job title, company, location, category, job type, salary, and ML-normalized skills, department and seniority - as JSON, CSV or Excel.

Bring your own API credentials and pay only for the results you keep.

### Why use this actor?

- **Global coverage** - postings aggregated from thousands of job boards and career pages worldwide, refreshed continuously.
- **ML-enriched fields** - normalized city, state and country, plus inferred department, seniority level and skills on top of the raw listing.
- **Full-text power search** - boolean AND / OR / NOT and exact phrases across job title and description.
- **Rich structured output** - title, company, location, category, job type, salary, source board, post date and apply link, parsed into flat columns.
- **Pay per result** - you are charged only for the postings actually returned, up to 5,000 per run.
- **Sandbox mode** - test your query with sample data before spending any job credits.
- **No proxies, no blocks** - data comes through a stable API, so runs are fast and reliable.

### Use cases

- **Job boards and aggregators** - stock your board with fresh, real listings across countries and categories.
- **Labor market research** - analyze hiring demand by role, skill, city or country over time.
- **Recruiting and sourcing** - track who is hiring for which roles and where.
- **Lead generation** - companies that are hiring are companies that are spending; time outreach on hiring signals.
- **Skills and salary intelligence** - mine inferred skills and posted salaries for compensation and talent studies.

### Input

Configure everything from the visual editor - every filter is a proper field, no code needed. Example JSON input:

```json
{
  "keywords": "\"data engineer\" AND (python OR spark)",
  "keywordField": "job_title_and_description",
  "country": "United States",
  "jobType": "full time",
  "postedAfter": "now-14d/d",
  "maxResults": 200,
  "clientId": "YOUR_CLIENT_ID",
  "apiKey": "YOUR_CLIENT_AUTH_KEY"
}
```

### Output

One clean JSON object per job posting:

```json
{
  "job_title": "Senior Data Engineer",
  "company_name": "Acme Corp",
  "location": "Austin, Texas, United States",
  "city": "Austin",
  "state": "Texas",
  "country": "United States",
  "category": "Information Technology",
  "job_type": "full time",
  "inferred_seniority_level": "Senior",
  "inferred_department_name": "Engineering",
  "inferred_skills": ["Python", "Spark", "AWS"],
  "salary_offered": "$150,000 - $180,000 a year",
  "post_date": "2026-07-18",
  "job_board": "companycareers",
  "url": "https://example.com/jobs/senior-data-engineer",
  "uniq_id": "a1b2c3d4e5f6"
}
```

### Do I need an API key?

Yes. This actor calls a job data feed API on your behalf, which requires your own **Client ID** and **Client Auth Key**. Generate them self-serve from your provider dashboard API keys page, paste both into the input, and run. Your credentials are stored securely and never logged. Select the **Sandbox** environment to validate your query with sample data before consuming any job credits.

### Pay per result

You pay only for the job postings the actor actually returns - no subscriptions, no minimums. Set **Maximum results** to cap each run's spend exactly.

### FAQ

#### What is the Jobs Data Feed API?

It is a job data-as-a-service API that continuously crawls and normalizes job postings from thousands of job boards and company career sites into a single structured feed. This actor queries that feed and returns matching postings - title, company, location, salary, category and ML-inferred skills and seniority - as ready-to-use JSON, CSV or Excel.

#### What filters can I use?

Full-text keywords with boolean operators and exact phrases (matched against title, description, or both), company name, category, city, state, country, job type, and a posted-on-or-after / posted-on-or-before date window. Power users can pass a raw Elasticsearch query object for full control.

#### Does it include salary and skills data?

Yes, where available. Each record can carry the posted salary text plus ML-inferred skills, department name and seniority level, in addition to the normalized city, state and country - useful for compensation benchmarking and talent analytics.

#### How many results can I get per run?

Up to 5,000 postings per run, collected up to 100 per request via cursor pagination. For larger pulls, split the query by country, category or date window, or schedule daily runs with a recent-date filter to collect new postings incrementally.

#### How recent is the data?

The underlying feed is refreshed continuously and includes newly discovered postings as well as historical listings. Use the posted-date filters to restrict results to a recent window, for example the last 7 or 14 days.

#### How much does it cost?

Pricing is pay-per-result: a small fixed amount per posting returned, plus standard Apify platform usage, plus your own API usage against your credentials. A run that returns nothing costs almost nothing. Use Sandbox mode to test for free.

#### Can I run this on a schedule?

Yes. Use Apify Schedules to run it hourly or daily and connect the dataset to Zapier, Make, n8n, webhooks or the API to pipe new postings into your ATS, CRM or data warehouse.

#### Is this legal?

The actor returns publicly available job listings retrieved through a licensed API using your own credentials. No login-walled or personal data is collected.

### Keyword map

job data api, job postings api, jobs data feed, job listings api, job market data api, hiring data api, recruitment data api, job scraping api, labor market data, job feed api, employment data api, jobs dataset.

### Support and feedback

Found an issue or missing a filter? Open an issue in the **Issues** tab - it is monitored daily.

# Actor input Schema

## `keywords` (type: `string`):

Free-text search across job title and description. Supports boolean operators AND, OR, NOT and quoted exact phrases, e.g. `"software engineer" AND (python OR golang) NOT senior`.

## `keywordField` (type: `string`):

Which field the keywords are matched against.

## `companyName` (type: `string`):

Restrict results to a single hiring company (exact-ish match on `company_name`).

## `category` (type: `string`):

Job category / department, e.g. `Information Technology`, `Sales`, `Healthcare`. Matches the `category` field.

## `city` (type: `string`):

City name. Matches the normalized `inferred_city` field.

## `state` (type: `string`):

State or region. Matches the normalized `inferred_state` field.

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

Country name, e.g. `United States`, `United Kingdom`, `India`. Matches the normalized `inferred_country` field.

## `jobType` (type: `string`):

Employment type filter (matches the `job_type` field).

## `postedAfter` (type: `string`):

Only jobs with a post date on or after this date. Accepts `YYYY-MM-DD` or relative Elasticsearch dates like `now-7d/d` (last 7 days). Matches `post_date`.

## `postedBefore` (type: `string`):

Only jobs with a post date on or before this date. Accepts `YYYY-MM-DD` or relative Elasticsearch dates. Matches `post_date`.

## `advancedQuery` (type: `object`):

Power users: provide a raw Elasticsearch query object that becomes `search_query_json`, e.g. `{"query_string":{"default_field":"job_title","query":"data engineer"}}`. When set, it overrides all the simple filters above.

## `environment` (type: `string`):

Use `Sandbox` to test without consuming job credits (returns sample data). Use `Production` for live data. Must match the credential pair you paste below.

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

Stop after this many job postings (1-5,000). Collected up to 100 per request via cursor pagination. You are charged per result returned.

## `clientId` (type: `string`):

Your Client ID for the job data API. Required. Get it self-serve from your provider dashboard API keys page.

## `apiKey` (type: `string`):

Your Client Auth Key. Required. Stored securely and never logged.

## Actor input object example

```json
{
  "keywordField": "job_title_and_description",
  "jobType": "",
  "environment": "production",
  "maxResults": 100
}
```

# 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 = {
    "keywords": "",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/jobs-data-feed-api").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 = {
    "keywords": "",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/jobs-data-feed-api").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 '{
  "keywords": "",
  "maxResults": 100
}' |
apify call nabeelbaghoor/jobs-data-feed-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nabeelbaghoor/jobs-data-feed-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/hwBkDJMugiRgIsYpm/builds/DHe0myE1l00ZgL6KY/openapi.json