# BLS Wage Data Scraper (`parseforge/bls-wage-data-scraper`) Actor

Collect economic data from the Bureau of Labor Statistics. Get CPI, unemployment rates, employment levels, hourly earnings, and PPI data. Select from pre-built series or enter custom IDs. Filter by year range and download structured time series data.

- **URL**: https://apify.com/parseforge/bls-wage-data-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 📈 BLS Wage Data Scraper

Whether you're an economist tracking inflation, a business analyst monitoring labor costs, or a researcher studying employment trends, this tool makes it easy to collect structured economic data from the Bureau of Labor Statistics.

> **The BLS Wage Data Scraper collects U.S. economic time series data including Consumer Price Index (CPI), unemployment rates, employment levels, average hourly earnings, and Producer Price Index. Select from 8 pre-built data series or enter any custom BLS series ID. Filter by year range and get monthly data points.**

### ✨ What Does It Do

- 📊 **Pre-built data series** - choose from CPI, Core CPI, unemployment rate, nonfarm employment, hourly earnings, PPI, labor force, and employment level
- 🔧 **Custom series support** - enter any valid BLS series ID to fetch specialized data
- 📅 **Year range filtering** - specify start and end years for your data (up to 10 years without a key, 20 with one)
- 📋 **Monthly data points** - get individual values for each month in your selected range
- 📝 **Footnotes included** - capture BLS footnotes and annotations for each data point
- 🔑 **Optional API key** - use your free BLS registration key for extended date ranges and higher rate limits

### 🔧 Input

- **Max Items** - how many data points to collect (free users get 10, paid users up to 1,000,000)
- **Data Series** - select from pre-built BLS series or choose "Custom" to enter your own
- **Custom Series ID** - enter a BLS series ID when using custom mode (find IDs at bls.gov/data)
- **Start Year** - beginning year for data retrieval (4-digit year)
- **End Year** - ending year for data retrieval (4-digit year)
- **BLS Registration Key** - optional free key from data.bls.gov for extended ranges

```json
{
    "seriesId": "CUUR0000SA0",
    "startYear": "2022",
    "endYear": "2024",
    "maxItems": 50
}
````

#### Available Data Series

| Series ID | Description |
|-----------|-------------|
| CUUR0000SA0 | Consumer Price Index (CPI) - All Items |
| CUSR0000SA0L1E | Core CPI - All Items Less Food and Energy |
| LNS14000000 | Unemployment Rate (Seasonally Adjusted) |
| CES0000000001 | Total Nonfarm Employees (Thousands) |
| CES0500000003 | Average Hourly Earnings - Total Private |
| WPUFD4 | Producer Price Index - Final Demand |
| LNS11000000 | Civilian Labor Force Level (Thousands) |
| LNS12000000 | Employment Level (Thousands) |

### 📊 Output

Each data point includes 8 fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| seriesId | BLS series identifier |
| seriesName | Human-readable series name |
| year | Data year |
| period | Period code (e.g., M01 for January) |
| periodName | Period name (e.g., January) |
| value | Data value for this period |
| footnotes | BLS footnotes and annotations |
| scrapedAt | Timestamp when data was collected |

```json
{
    "seriesId": "CUUR0000SA0",
    "seriesName": "Consumer Price Index - All Urban Consumers, All Items",
    "year": "2024",
    "period": "M12",
    "periodName": "December",
    "value": "315.605",
    "footnotes": "",
    "scrapedAt": "2026-04-08T16:52:14.908Z"
}
```

### 💎 Why Choose the BLS Wage Data Scraper?

| Feature | Our Tool | Manual BLS Website |
|---------|----------|--------------------|
| Batch collection | Up to 1M data points | Download tables manually |
| Pre-built series | 8 popular indicators | Navigate complex menus |
| Custom series | Any BLS series ID | Find series one at a time |
| Structured output | JSON, CSV, Excel | Varies by tool |
| Automated scheduling | Daily/weekly updates | Manual downloads |
| Year range control | Up to 20 years | Limited by tool |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - select your data series, set the year range, and choose how many data points
3. **Run It** - click "Start" and get structured economic data in seconds

No coding, no setup, no manual downloads required.

### 🎯 Business Use Cases

- 📈 **Economists** - track CPI and inflation trends for economic analysis and forecasting
- 💼 **HR departments** - monitor wage data and employment levels for compensation planning
- 🏦 **Financial analysts** - incorporate BLS data into models for investment decisions
- 📰 **Journalists** - pull official government statistics for economic reporting
- 🎓 **Researchers** - collect time series data for academic studies on labor markets and prices
- 🏢 **Businesses** - benchmark hourly earnings against national averages for competitive positioning

### ❓ FAQ

📊 **What is BLS?**
The Bureau of Labor Statistics (BLS) is the principal federal agency responsible for measuring labor market activity, working conditions, price changes, and productivity in the U.S. economy.

🔑 **Do I need a BLS API key?**
No. The scraper works without a key (limited to 10-year ranges). For 20-year ranges and higher rate limits, register for a free key at data.bls.gov/registrationEngine.

📅 **What date ranges are supported?**
Without a registration key: up to 10 years. With a key: up to 20 years per request.

⏱️ **How long does a run take?**
Under 5 seconds for most requests. BLS returns data very quickly.

🔧 **How do I find custom series IDs?**
Visit bls.gov/data and browse by topic. Each data table shows its series ID.

### 🔗 Integrate BLS Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate economic data collection workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Trigger actions when new data is published
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get CPI or unemployment updates in your channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export time series data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more economic and government data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Grants.gov Scraper | Collect federal grant opportunities | [Link](https://apify.com/parseforge/grants-gov-scraper) |
| USASpending Scraper | Gather federal spending and award data | [Link](https://apify.com/parseforge/usaspending-scraper) |
| Federal Register Scraper | Collect regulatory notices and rules | [Link](https://apify.com/parseforge/federal-register-regulatory-notices-rules-scraper) |
| FINRA BrokerCheck Scraper | Look up broker registration data | [Link](https://apify.com/parseforge/finra-brokercheck-scraper) |
| GSA eLibrary Scraper | Collect government contract data | [Link](https://apify.com/parseforge/gsa-elibrary-scraper) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to the U.S. Bureau of Labor Statistics or the U.S. Department of Labor. It accesses only publicly available data through the official BLS public API.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `seriesId` (type: `string`):

Select a BLS data series to fetch

## `customSeriesId` (type: `string`):

Enter a custom BLS series ID (only used when Data Series is set to Custom). Find series IDs at https://www.bls.gov/data/

## `startYear` (type: `string`):

Start year for data retrieval (4-digit year)

## `endYear` (type: `string`):

End year for data retrieval (4-digit year)

## `registrationKey` (type: `string`):

Optional BLS API registration key for higher rate limits and extended date ranges (up to 20 years). Register free at https://data.bls.gov/registrationEngine/

## Actor input object example

```json
{
  "maxItems": 10,
  "seriesId": "CUUR0000SA0",
  "startYear": "2022",
  "endYear": "2024"
}
```

# Actor output Schema

## `data` (type: `string`):

Complete dataset with all BLS time series data points

## `overview` (type: `string`):

Overview of data points with key fields

# 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 = {
    "maxItems": 10,
    "seriesId": "CUUR0000SA0",
    "startYear": "2022",
    "endYear": "2024"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/bls-wage-data-scraper").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 = {
    "maxItems": 10,
    "seriesId": "CUUR0000SA0",
    "startYear": "2022",
    "endYear": "2024",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/bls-wage-data-scraper").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 '{
  "maxItems": 10,
  "seriesId": "CUUR0000SA0",
  "startYear": "2022",
  "endYear": "2024"
}' |
apify call parseforge/bls-wage-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/bls-wage-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BLS Wage Data Scraper",
        "description": "Collect economic data from the Bureau of Labor Statistics. Get CPI, unemployment rates, employment levels, hourly earnings, and PPI data. Select from pre-built series or enter custom IDs. Filter by year range and download structured time series data.",
        "version": "0.0",
        "x-build-id": "ofGrbArNaRFxagRUu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~bls-wage-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-bls-wage-data-scraper",
                "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/parseforge~bls-wage-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-bls-wage-data-scraper",
                "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/parseforge~bls-wage-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-bls-wage-data-scraper",
                "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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "seriesId": {
                        "title": "Data Series",
                        "enum": [
                            "CUUR0000SA0",
                            "CUSR0000SA0L1E",
                            "LNS14000000",
                            "CES0000000001",
                            "CES0500000003",
                            "WPUFD4",
                            "LNS11000000",
                            "LNS12000000",
                            "all",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Select a BLS data series to fetch"
                    },
                    "customSeriesId": {
                        "title": "Custom Series ID",
                        "type": "string",
                        "description": "Enter a custom BLS series ID (only used when Data Series is set to Custom). Find series IDs at https://www.bls.gov/data/"
                    },
                    "startYear": {
                        "title": "Start Year",
                        "type": "string",
                        "description": "Start year for data retrieval (4-digit year)"
                    },
                    "endYear": {
                        "title": "End Year",
                        "type": "string",
                        "description": "End year for data retrieval (4-digit year)"
                    },
                    "registrationKey": {
                        "title": "BLS Registration Key (Optional)",
                        "type": "string",
                        "description": "Optional BLS API registration key for higher rate limits and extended date ranges (up to 20 years). Register free at https://data.bls.gov/registrationEngine/"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
