# H-1B Employer Wage Lookup (`a.jonzy/h1b-employer-wage-lookup`) Actor

Wage percentiles (p10 to p90) for U.S. employers from DOL LCA filings, benchmarked to BLS OEWS, with sources.

- **URL**: https://apify.com/a.jonzy/h1b-employer-wage-lookup.md
- **Developed by:** [Aidan Jones](https://apify.com/a.jonzy) (community)
- **Categories:** Jobs, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## H-1B Employer Wage Lookup: wage percentiles from DOL LCA filings, benchmarked to BLS OEWS

Look up how much a U.S. employer pays for H-1B roles. For each employer name you give, this Actor returns **wage percentiles (p10, p25, p50, p75, p90)** computed from certified Labor Condition Application (LCA) filings published by the U.S. Department of Labor, plus the **ratio of the employer's median to the BLS OEWS median** for the same occupations. It does not return raw filing rows: you get the summary you would otherwise build yourself from the DOL spreadsheets. Every record carries its sources and release dates.

Official data only. Nothing is scraped from any website; the Actor reads a cleaned copy of the DOL and BLS files through a hosted API.

### What you get

For each employer:

- Number of certified LCA filings and wage percentiles in USD (p10, p25, p50, p75, p90)
- `medianVsOewsRatio`: employer median divided by the BLS OEWS median (above 1 means certified wages run higher than the OEWS median for those occupations)
- Wage level mix (Level I to IV share of filings)
- Top states and top occupations, each with filings and median
- `sources` (DOL OFLC disclosure file and BLS OEWS release, with as-of dates) and a data notice

### Price

Pay per event, no subscription:

| Event | Price |
|---|---|
| Actor start | $0.005 per start event. Apify bills one start event per GB of memory, minimum one; the default run here uses 512 MB, so one event |
| Employer found | $0.01 per employer returned with data |

Employers that are not found are **free** and come back as `status: "not_found"`. Example: 100 employers with 90 found costs $0.005 + 90 x $0.01 = $0.905. With `fuzzy` on (the default), a close-name match counts as found and is charged; the item says `match: "fuzzy"` and shows `matchedName`. Turn `fuzzy` off to be charged only for exact matches. Set a maximum cost per run in the Apify run options and the Actor stops cleanly when it is reached.

### Example input (works as is)

```json
{
  "employers": ["Amazon", "Google"],
  "fuzzy": true,
  "topOccupations": 5,
  "maxItems": 100
}
```

| Field | Meaning |
|---|---|
| `employers` | Employer names, one per line, for example `Amazon`, `Google` |
| `fuzzy` | Use the best search match when the exact name is not found (default on) |
| `topOccupations` | How many top occupations and states to include per employer (default 5, max 25) |
| `maxItems` | Safety cap on employers per run (default 100, max 1000) |

### Example output

Trimmed from a real run of this Actor (the full item also has `wageLevelPct`, more states and occupations, and a `notice` string):

```json
{
  "query": "Amazon",
  "status": "found",
  "match": "exact",
  "matchedName": "Amazon",
  "employer": "Amazon",
  "slug": "amazon",
  "filings": 20053,
  "wagePercentilesUsd": { "p10": 117749, "p25": 133000, "p50": 158000, "p75": 181293, "p90": 204160 },
  "medianVsOewsRatio": 1.01,
  "wageLevelPct": { "I": 23.7, "II": 46.3, "III": 17, "IV": 13 },
  "topStates": [{ "state": "WA", "filings": 10394 }, { "state": "CA", "filings": 3018 }],
  "topOccupations": [{ "soc": "15-1252", "title": "Software Developers", "filings": 10267, "p50": 162600, "oews_us_median": 135980 }],
  "sources": [
    { "name": "DOL OFLC LCA Disclosure Data FY2026 Q3", "as_of": "FY2026 Q3 release", "url": "https://www.dol.gov/agencies/eta/foreign-labor/performance" },
    { "name": "BLS OEWS May 2025", "as_of": "May 2025", "url": "https://www.bls.gov/oes/tables.htm" }
  ]
}
```

A not-found employer returns `{ "query": "...", "status": "not_found" }`. A failed lookup returns `status: "error"` with `httpStatus` and `error`. A run summary (`requested`, `found`, `notFound`, `errors`) is saved under the key-value store key `SUMMARY`.

### Data and limits (read this)

- **Wages are the bottom of each filing's offered range** (`WAGE_RATE_OF_PAY_FROM`), so medians run low against what people are paid and against OEWS. Percentiles are unweighted per filing (each certified filing counts once).
- Percentiles describe wages certified on LCA filings, not the actual pay of every employee. Employer level only, no individual names.
- Coverage is the set of employers loaded in the data API; live counts are on https://data-api.premed-toolkit.workers.dev/docs. Employers outside it return `not_found` (free). The data API loads only employers with at least 10 certified filings.
- Data is refreshed when the DOL publishes a new quarterly disclosure file.
- Source: U.S. Department of Labor OFLC LCA disclosure data and BLS Occupational Employment and Wage Statistics, both U.S. government publications. Not legal, immigration, or financial advice. Not affiliated with or endorsed by DOL or BLS.

### FAQ

**Do I need an API key or a DOL account?** No. Press Start.

**Why is an employer I know not found?** The employer may not be in the loaded set (see the live counts on the docs page), and names must resemble the DOL's employer name. Try the legal name (for example `Tata Consultancy Services Limited`) or leave `fuzzy` on. Not-found is free.

**How is this different from a raw H-1B scraper?** Those return filing rows. This returns the percentiles and an OEWS comparison, so you pay for one summary per employer instead of thousands of rows.

**Can I call it from an AI agent?** Yes. Apify exposes Actors as tools through its MCP server (see https://docs.apify.com/platform/integrations/mcp), and the input and output are small and structured. It also works from Make, Zapier, n8n and the Apify API.

**How often should I run it?** Quarterly is enough; the DOL publishes new disclosure data every quarter.

**I need thousands of lookups a month.** Use the direct API: free tier (100 calls per month) and paid plans, with plans, docs and a quickstart at https://data-api.premed-toolkit.workers.dev/docs. More data and tools: https://filedwages.com

### Related

- [Occupation Salary by Metro](https://apify.com/a.jonzy/occupation-salary-by-metro): the same LCA-versus-OEWS comparison for an occupation in a metro area.

# Actor input Schema

## `employers` (type: `array`):

Employer names to look up, for example Amazon or Google. Names are matched to the DOL employer list; a close match is used when the exact name is not found.

## `fuzzy` (type: `boolean`):

If the exact employer is not found, use the best search match.

## `topOccupations` (type: `integer`):

How many occupations and states to include per employer.

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

Safety cap on how many employers are processed in one run.

## Actor input object example

```json
{
  "employers": [
    "Amazon",
    "Google"
  ],
  "fuzzy": true,
  "topOccupations": 5,
  "maxItems": 100
}
```

# Actor output Schema

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

One item per employer requested. Items have status found, not_found or error.

## `summary` (type: `string`):

Counts of found, not found and error items, and whether the run stopped at the charge limit.

# 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 = {
    "employers": [
        "Amazon",
        "Google"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("a.jonzy/h1b-employer-wage-lookup").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 = { "employers": [
        "Amazon",
        "Google",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("a.jonzy/h1b-employer-wage-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "employers": [
    "Amazon",
    "Google"
  ]
}' |
apify call a.jonzy/h1b-employer-wage-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,a.jonzy/h1b-employer-wage-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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