# Job Market Data API - Job Postings, Wages and Labor Market Data (`nabeelbaghoor/job-market-data-api`) Actor

Search real-time job postings and labor market data by region, occupation, industry and skill, and export structured records with wages, job titles, employers and SOC codes. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/job-market-data-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

$10.00 / 1,000 job posting 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

## Job Market Data API - job postings, wages and labor market data

**Job Market Data API** turns real-time job postings and labor market data into a clean, structured export. Filter live postings by region, occupation, industry and skill, then export records with job titles, employers, locations, wages and SOC occupation codes as JSON, CSV or Excel.

Bring your own API key and pay only for the records you keep.

### Why use this actor?

- **Real-time job postings** - search current openings by keyword, title, occupation, industry and skill.
- **Wage and occupation data** - each posting carries its wage (actual or modelled), SOC occupation code and label.
- **Region granularity** - filter by state, metro area (MSA), county, country or the total nation.
- **Structured output** - job title, employer, location, wage, occupation, first-seen and last-seen dates and the posting URL, parsed into flat columns.
- **Pay per result** - you are charged only for the postings actually returned, up to 5,000 per run.
- **No proxies, no blocks** - data comes through a stable API, so runs are fast and reliable.

### Use cases

- **Labor market research** - measure hiring demand by occupation, skill and geography.
- **Wage benchmarking** - pull posted and modelled wages for a role across regions.
- **Talent sourcing** - find live openings for a title or skill in a target market.
- **Competitive hiring intelligence** - track which employers are posting and where.
- **Workforce and economic planning** - feed regional job-posting counts into models and dashboards.

### Input

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

```json
{
  "freetext": "registered nurse",
  "regionType": "MSA",
  "regionCode": 1698,
  "postState": "Active",
  "maxResults": 100,
  "apiKey": "YOUR_API_KEY"
}
```

Filter by occupation and skill in a state, within a date range:

```json
{
  "occupation": "software developers",
  "skill": "aws",
  "regionType": "State",
  "regionCode": 39,
  "startDate": "2026-01-01",
  "endDate": "2026-03-31",
  "maxResults": 250,
  "apiKey": "YOUR_API_KEY"
}
```

### Output

One clean JSON object per job posting:

```json
{
  "id": "123456789",
  "title": "Senior Software Developer",
  "company": "Acme Corp",
  "location": "Columbus, OH",
  "wage": 128000,
  "socCode": "15-1252",
  "socLabel": "Software Developers",
  "jobTypes": ["Full-time"],
  "active": true,
  "dateStart": "2026-02-04",
  "dateEnd": "2026-02-28",
  "url": "https://example.com/jobs/123456789"
}
```

### Do I need an API key?

Yes. This actor calls a job market data API on your behalf, which requires your own **API key**. The key is provisioned by the provider for your licensed account and passed as an `EQ-Key` credential. Paste it into the input and run. Your key is stored securely and never logged.

### 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 Job Market Data API?

It is a labor market data API that serves real-time job postings enriched with wages and standardized occupation (SOC) codes, filterable by region, occupation, industry and skill. This actor runs that search and exports the matching postings as JSON, CSV or Excel.

#### What filters can I use?

Free-text keyword search plus contains-filters for job title, occupation, industry and skill, a region (state, metro area, county, country or nation) with its numeric code, a posted-date range, posting status and ad type (all, staffing or non-staffing).

#### How do I find region codes?

Region is a type plus a numeric code, for example State 39 for Ohio or MSA 1698 for Chicago. Use the provider's region, industry and occupation lookup endpoints to resolve names to codes, then paste the code into the Region code field. For multiple regions, use the advanced Regions field.

#### What data is included per posting?

Where available, each record carries the job title, employer, location, wage (actual or modelled), SOC occupation code and label, job type, active flag, first-seen and last-seen dates and the posting URL.

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

Up to 5,000 job postings per run, paged automatically. For larger pulls, split by region, occupation or date range across multiple runs.

#### How much does it cost?

Pricing is pay-per-result: a small fixed amount per job posting returned, plus standard Apify platform usage, plus your own API usage against your key. A run that returns nothing costs almost nothing.

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

Yes. Use Apify Schedules to run it daily or weekly and connect the dataset to Zapier, Make, n8n, webhooks or the API to push new postings into your database or dashboard.

#### Is this legal?

The actor returns job posting and labor market data retrieved through a licensed API using your own credentials. It focuses on aggregated hiring and labor market information.

### Keyword map

job market data api, job postings api, labor market data api, real-time jobs api, wage data api, occupation data api, soc code api, hiring demand api, labor market analytics api, job search api, workforce data api, employment data api.

### Support and feedback

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

# Actor input Schema

## `freetext` (type: `string`):

Free-text search across job postings, e.g. `registered nurse` or `python developer`. Combined with the filters below.

## `title` (type: `string`):

Keep only postings whose title contains this text, e.g. `data engineer`.

## `occupation` (type: `string`):

Filter by occupation name (SOC), e.g. `software developers`.

## `industry` (type: `string`):

Filter by industry name (NAICS), e.g. `hospitals`.

## `skill` (type: `string`):

Filter by a required skill, e.g. `sql` or `aws`.

## `regionType` (type: `string`):

Geography level for the region code below. Use the reference lookups in the provider docs to find codes.

## `regionCode` (type: `integer`):

Numeric region code for the selected region type, e.g. State 39 = Ohio, MSA 1698 = Chicago. Leave empty to search all regions (subject to your license coverage).

## `regions` (type: `array`):

Power users: an array of region objects `[{ "type": "State", "code": 39 }, { "type": "MSA", "code": 1698 }]`. When set, this replaces the single region type/code above.

## `startDate` (type: `string`):

Only postings first seen on or after this date (YYYY-MM-DD).

## `endDate` (type: `string`):

Only postings first seen on or before this date (YYYY-MM-DD).

## `postState` (type: `string`):

Which postings to include by lifecycle state.

## `adType` (type: `string`):

Include all postings, or restrict to staffing-agency or non-staffing postings.

## `dataset` (type: `string`):

US or Global job posting dataset (subject to your license).

## `excludeStaffing` (type: `boolean`):

Drop postings from staffing agencies.

## `useImputedWages` (type: `boolean`):

Fill missing wages with the provider's modelled wage estimates.

## `filters` (type: `array`):

Power users: an array of filter objects `[{ "field": "title", "key": "data engineer", "filterType": "contains" }]`. Appended to the filters built from the fields above. `field` can be title, occupation, industry, skill or keyword.

## `startRecord` (type: `integer`):

1-based record to start from. Increase to skip earlier results.

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

Stop after this many job postings (1-5,000). Paged automatically. You are charged per result returned.

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

Your labor market data API key. Required. It is provisioned by the provider for your licensed account and sent as an `EQ-Key` credential. Stored securely and never logged.

## Actor input object example

```json
{
  "regionType": "State",
  "postState": "Active",
  "adType": "All",
  "dataset": "US",
  "excludeStaffing": false,
  "useImputedWages": false,
  "startRecord": 1,
  "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 = {
    "maxResults": 100
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

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