BLS Occupational Outlook Handbook Scraper: 19 Data Fields per Record

Extract structured wage, employment, and outlook metrics for 300+ US occupations directly from the Bureau of Labor Statistics website. Each record carries 19 output fields. On the free plan, results cost $0.005 per item, or $5.00 per 1,000 results, and up to 1,000 results can be extracted per month. Built for labor market researchers, career advisors, and compensation analysts; not for users who need real-time local job postings, which this national handbook does not aggregate.

Try it: open BLS Occupational Outlook Handbook Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try BLS Occupational Outlook Handbook Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of BLS Occupational Outlook Handbook Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 10, so a first run returns at most 10 results and costs at most $0.05 in result charges. That is enough to see the real shape of the data before deciding anything.

BLS Occupational Outlook Handbook Scraper was last updated on 2026-06-06. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 692,561 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run BLS Occupational Outlook Handbook Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The maxItems parameter drives overall cost by capping how many records are written to the dataset. Running a narrow query with mode set to byOccupation or maxItems set to 10 ensures your first run stays under $0.05 in result charges. The minMedianWage filter applies before results are written, so setting it effectively reduces your item count and thus your result charges.

How do you run BLS Occupational Outlook Handbook Scraper from the API?

The schema marks 1 of its 6 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~bls-ooh-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"byOccupationGroup","occupationGroup":"Healthcare Practitioners and Technical","maxItems":10}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "byOccupationGroup",
  "occupationGroup": "Healthcare Practitioners and Technical",
  "maxItems": 10
}

run = client.actor("crawlerbros~bls-ooh-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "byOccupationGroup",
  "occupationGroup": "Healthcare Practitioners and Technical",
  "maxItems": 10
}

const run = await client.actor('crawlerbros~bls-ooh-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which BLS Occupational Outlook Handbook Scraper inputs matter, and which can you skip?

The mode parameter controls how occupations are retrieved, offering allOccupations, byOccupationGroup, searchByKeyword, and byOccupation. When using byOccupationGroup, select a group from occupationGroup, or enter a text string in keyword for searchByKeyword. First-time users should keep minMedianWage empty and set maxItems to 10.

• mode (string): How to fetch occupations. Default: "byOccupationGroup".
• occupationGroup (string): Major occupation group to browse (mode=byOccupationGroup). Default: "Healthcare Practitioners and Technical".
• keyword (string): Filter occupations by keyword in title (mode=searchByKeyword). E.g. 'nurse', 'engineer', 'manager'.
• occupationUrl (string): Full URL or relative path for a specific occupation (mode=byOccupation). E.g. '/ooh/healthcare/physicians-and-surgeons.htm' or 'https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm'.
• minMedianWage (integer): Filter out occupations with median annual wage below this threshold.
• maxItems (integer): Maximum number of occupation records to return. Default: 50.

Fixed-choice controls: mode accepts allOccupations (A-Z index, ~330 occupations), byOccupationGroup (Browse by occupation group), searchByKeyword (Search by keyword in title), byOccupation (Specific occupation URL or slug); occupationGroup accepts 23 values (default Healthcare Practitioners and Technical), including Healthcare Practitioners and Technical, Management, Business and Financial Operations, Computer and Information Technology.

What does BLS Occupational Outlook Handbook Scraper return?

Output items contain structured metrics such as median_annual_wage_usd, employment_percent_change_10yr, and entry_level_education. They work well for wage benchmarking and workforce trend analysis. They do not contain individual job openings, employer contact information, or city-level salary distributions.

• occupation_title: String - Occupation name
• occupation_group: String - Major occupation group
• median_annual_wage_usd: Integer - Median annual wage in USD
• median_hourly_wage_usd: Number - Median hourly wage in USD
• employment_count: Integer - Number of jobs in the reference year
• employment_percent_change_10yr: Number - Projected % change in employment over 10 years
• job_outlook_category: String - Growth category (e.g., "Faster than average")
• entry_level_education: String - Typical education to enter the occupation
• work_experience: String - Work experience requirement
• on_the_job_training: String - On-the-job training requirement
• number_of_jobs: Integer - Total number of jobs
• projected_employment_change: Integer - Projected new jobs over 10 years
• occupation_code: String - SOC code
• summary: String - Brief occupation description
• typical_duties: Array - List of common job duties
• work_settings: Array - List of common work environments
• related_occupations: Array - List of similar occupations
• url: String - BLS OOH page URL
• scrapedAt: String - ISO-8601 scrape timestamp

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open BLS Occupational Outlook Handbook Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Set mode to byOccupationGroup to target a specific category without fetching the entire handbook.
2. Select Healthcare Practitioners and Technical in the occupationGroup drop-down parameter.
3. Set maxItems to 10 on your first run to limit the output volume.
4. Execute the run and verify in the dataset tab that records contain non-null values for median_annual_wage_usd and employment_count.
5. Check that typical_duties returns an array of descriptive strings for the fetched records.
6. Adjust minMedianWage to an integer such as 50000 if you need to exclude lower-wage occupations.
7. Switch mode to allOccupations and set maxItems to 1000 when ready to extract the full handbook dataset.

How do you apply it? Three worked playbooks

These are BLS Occupational Outlook Handbook Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Career research

Outcome: Compare wages and outlook across occupation groups

Configure: Set mode to byOccupationGroup, occupationGroup to Healthcare Practitioners and Technical, and maxItems to 50.

Working method: Execute the run for the selected group, calculate the average median_annual_wage_usd across the returned items, and repeat for additional occupationGroup values.

Deliverable: A structured dataset of occupations with median annual wages and 10-year growth categories across selected groups.

Stop condition: Stop if median_annual_wage_usd returns null or missing across five consecutive dataset items.

Use case 2: Workforce analytics

Outcome: Analyze labor market trends and projected job growth

Configure: Set mode to allOccupations and maxItems to 500.

Working method: Start from a full handbook run, sort the dataset by employment_percent_change_10yr, and group records by job_outlook_category.

Deliverable: A CSV dataset ranking 300+ occupations by projected 10-year employment change and job growth rate.

Stop condition: Stop if employment_percent_change_10yr is absent from the extracted dataset items.

Use case 3: Education planning

Outcome: Map education requirements to occupations

Configure: Set mode to searchByKeyword, keyword to engineer, and maxItems to 100.

Working method: Search for occupations using a keyword string, aggregate the output by entry_level_education, and calculate median salaries for each credential level.

Deliverable: A dataset mapping entry_level_education values to median_annual_wage_usd and projected_employment_change.

Stop condition: Stop if entry_level_education contains blank values in the initial output batch.

What breaks, and how do you design around it?

If maxItems truncates your dataset before covering a whole group, switch mode to searchByKeyword or split requests by specific occupationGroup selections. For occupations earning above survey bounds where wage strings appear, handle threshold limits explicitly in your ingestion logic. If you need task-level breakdown models, complement this dataset with taxonomy scrapers.

When should you not use BLS Occupational Outlook Handbook Scraper?

Do not use this Actor if you need task taxonomies, technical skill classifications, or Job Zone ratings instead of general handbook statistics. For detailed skill and task structures, use the O*NET Occupation Data Scraper. Skip this scraper if you require macro economic time-series data like CPI inflation or national unemployment numbers; use the BLS Labor Statistics Scraper instead, which interfaces directly with the BLS public API v1. If your workflow requires contractor trade employment numbers and weekly hours from the CES program, use the US National Contractor Employment & Wages (BLS).

What should you check before trusting the output?

• Confirm that median_annual_wage_usd contains an integer or threshold number rather than null.
• Verify that employment_percent_change_10yr is populated as a numeric percentage.
• Ensure typical_duties and work_settings return non-empty array objects.
• Abort scheduled runs if entry_level_education returns empty string values across an entire batch.

None of this proves a record is correct. It gives a scheduled BLS Occupational Outlook Handbook Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to scrape all occupations?

Extracting all ~330 occupations from the index generates approximately 330 dataset items. At $0.005 per result ($5.00 per 1,000 results on the free plan), scraping the entire handbook costs about $1.65 in result fees plus platform usage.

Is a BLS API key required?

No API key or registration is required. The scraper extracts public data directly from the BLS Occupational Outlook Handbook website.

How are high-wage occupations formatted?

For occupations with median annual salaries exceeding standard survey caps, the BLS reports an upper threshold string. The Actor captures this value directly into the dataset record.

Can I filter occupations by salary before scraping?

Yes. Set minMedianWage to an integer USD amount to exclude occupations with median annual wages below that threshold from the returned dataset.

How often is the handbook data updated?

The Bureau of Labor Statistics updates Occupational Outlook Handbook data periodically, typically every 2 years, updating wage figures from recent Occupational Employment and Wage Statistics surveys.

Where to go next

When you are ready to run it, open BLS Occupational Outlook Handbook Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the BLS Occupational Outlook Handbook Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• BLS Labor Statistics Scraper: Fetch U.S. Bureau of Labor Statistics (BLS) time-series data - employment, unemployment, inflation (CPI), wages, and more - via the free BLS public API v1.
• BLS Labor Statistics Scraper: Scrape US Bureau of Labor Statistics (BLS) employment, unemployment, and wage data by industry sector and state.
• US National Contractor Employment & Wages (BLS): Scrape US NATIONAL contractor employment numbers, average wages, and weekly hours by construction trade via the Bureau of Labor Statistics CES program.
• O*NET Occupation Data Scraper: Scrape O*NET OnLine (US Dept. of Labor) occupation data: SOC lookup, keyword search, browse by Job Zone or Bright Outlook.

Related guides:

• O*NET Occupation Data Scraper: 3 Practical Use Cases

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-28.

• Actor last updated by its maintainers on 2026-06-06.

• Run outcome figures cover the 30 day public window ending 2026-09-28.

• BLS Occupational Outlook Handbook Scraper on Apify