# Levels.fyi Scraper (`haketa/levels-fyi-scraper`) Actor

Levels.fyi scraper & API: export tech compensation by company, level and location — base salary, stock, bonus, total comp, title, years of experience and date. Salary benchmarking, comp intelligence and talent-market data — fast, no login.

- **URL**: https://apify.com/haketa/levels-fyi-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Features:** Limited permissions
- **Stats:** 10 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 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/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

## 💰 Levels.fyi Scraper — Tech Salary, Total Compensation & Stock Grant Data by Company, Level & Role

**Extract verified tech compensation data from [Levels.fyi](https://www.levels.fyi) — median total compensation, base salary, annual stock grants (RSUs), bonuses, p10–p90 percentile spreads and sample counts by company, level, role and location. No login, no coding.** This **Levels.fyi scraper** is a structured **Levels.fyi API alternative** built for compensation benchmarking, candidate offer negotiation, recruiter sourcing intelligence, People Ops band calibration and equity research.

Export every record to **JSON, CSV, Excel, or API** with automatic multi-company and multi-role expansion supporting **1,000+ compensation records**.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00b04f?style=flat-square\&logo=apify)](https://apify.com/haketa/levels-fyi-scraper)
[![Live Data](https://img.shields.io/badge/Data-Live%20Verified%20Comp-orange?style=flat-square)](https://apify.com/haketa/levels-fyi-scraper)
[![Companies](https://img.shields.io/badge/Companies-3%2C000%2B%20Supported-purple?style=flat-square)](https://apify.com/haketa/levels-fyi-scraper)
[![Pagination](https://img.shields.io/badge/Scale-1%2C000%2B%20Level%20Records-blue?style=flat-square)](https://apify.com/haketa/levels-fyi-scraper)
[![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel%20%7C%20API-2b7489?style=flat-square)](https://apify.com/haketa/levels-fyi-scraper)
[![No Auth](https://img.shields.io/badge/Login-None%20Required-success?style=flat-square)](https://apify.com/haketa/levels-fyi-scraper)

> Built for **technical recruiters, compensation & People Ops analysts, hiring managers, software engineers negotiating offers, venture capital / equity researchers, and B2B workforce intelligence teams**.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Source platform** | [Levels.fyi (`levels.fyi`)](https://www.levels.fyi) — Crowdsourced & verified tech compensation benchmarks |
| **Granularity** | One structured record per **company × role × level** (e.g. Google · Software Engineer · L5) |
| **Built-in dropdowns** | 19 top tech employers + 20 job families + 23 global metro locations + unlimited custom slugs & URLs |
| **Compensation metrics** | Level Median TC (`totalCompensation`), Role Median Split (`baseSalary`, `stockGrant`, `bonus`), Percentiles (`p10TC`–`p90TC`) |
| **Workforce & YoE context** | `levelTitle`, `levelSampleCount`, `sampleCountLast12Months`, `percentWorkforce`, `typicalYoeMin`, `typicalYoeMax` |
| **1,000+ scaling** | Automatic expansion across 20 job families and 100+ top tech companies when `maxResults` exceeds initial selection |
| **Deduplication** | Strictly deduplicated on `companySlug + jobFamily + level` (0 duplicate rows) |
| **Export formats** | Bulk export to JSON, CSV, Excel, HTML, Webhook & Apify REST API |

***

### 🔎 Why scrape Levels.fyi?

[Levels.fyi](https://www.levels.fyi) is the leading benchmark database for **verified technology compensation**, mapping hundreds of thousands of real compensation submissions onto each employer's internal leveling ladder — such as **Google L3–L9**, **Meta E3–E9**, **Amazon SDE I–Principal (L4–L8)**, **Apple ICT2–ICT6**, **Microsoft 59–80**, **NVIDIA IC1–IC8**, and equivalents across thousands of public and late-stage private tech companies.

For every company and job family, Levels.fyi publishes:

- **Per-level median total compensation (`totalCompensation`)**,
- **Role-wide base salary, annual stock grant (RSU) and bonus medians**,
- **10th, 25th, 50th, 75th and 90th percentile total compensation spreads (`p10TC`–`p90TC`)**,
- **Submission sample counts (`levelSampleCount` and `sampleCountLast12Months`)**, and
- **Typical years of experience (`typicalYoeMin`–`typicalYoeMax`) and workforce distribution (`percentWorkforce`)**.

Collecting those numbers manually across dozens of companies, job families and levels takes hours of clicking and copying, and there is no public self-serve **Levels.fyi API**. This **Levels.fyi data extractor** automates the entire workflow: select your companies and roles (or set a high `maxResults` target for a market-wide sweep) and get clean, normalized USD integers ready for Excel, Google Sheets, Snowflake, BigQuery or BI dashboards.

**Common reasons teams use this Levels.fyi scraper:**

- 💼 **Candidate offer negotiation** — compare a live offer against the verified level median (`medianTC`) and 75th percentile (`p75TC`) for that exact company and rung.
- 🎯 **Executive & technical recruiting** — build competitive offer sheets per level across target talent pools before extending compensation packages.
- 📊 **People Ops & compensation band calibration** — benchmark internal engineering, product, data and design salary bands against FAANG, AI labs and cloud leaders.
- 📈 **Venture capital & equity research** — model R\&D payroll burn, stock-based compensation (SBC) dilution and headcount distribution (`percentWorkforce`) across public and private tech portfolios.
- 🧠 **AI & labor-market analytics** — track how total compensation scales from entry-level IC to Principal/Staff engineer across companies and roles over time.

***

### ✨ What this Levels.fyi scraper does

- ✅ **Zero-code dropdown targeting** — select companies (`google`, `meta`, `amazon`, `apple`, `microsoft`, `netflix`, `nvidia`, `uber`, `airbnb`, `stripe`, `openai`, `databricks`, `salesforce`, `oracle`, `adobe`, `linkedin`, `snowflake`, `tesla`, `coinbase`) and 20 job families directly in the UI.
- ✅ **Custom company slugs & direct URLs** — add any off-list employer via `customCompanies` (e.g. `palantir`, `doordash`, `anthropic`, `scale-ai`, `citadel`, `jane-street`) or paste exact Levels.fyi salary URLs into `urls`.
- ✅ **One row per level** — emits a dedicated record for every level on the company/role ladder (`L3`, `L4`, `L5`, `L6`, `L7`, `L8`…) with its exact median total compensation.
- ✅ **Unlocked 1,000+ record scaling** — when you request a large dataset (e.g. `maxResults: 1000`), the scraper automatically expands across all 20 job families and 100+ top tech companies so runs never stall at single-company limits.
- ✅ **Complete percentile context** — captures `p10TC`, `p25TC`, `medianTC` (`p50`), `p75TC` and `p90TC` alongside `medianBase`, `medianStock` and `medianBonus`.
- ✅ **Sample confidence & workforce share** — includes `levelSampleCount`, `sampleCountLast12Months`, `percentWorkforce`, `typicalYoeMin`, `typicalYoeMax` and midpoint `yearsOfExperience`.
- ✅ **Clean integer normalization** — all dollar figures are converted to clean USD integers (`426881`, `200000`) with ISO timestamps (`dataDate`, `scrapedAt`).

***

### 🎯 Use cases

| Persona | How they use this Actor |
|---|---|
| **👩‍💼 Compensation & Total Rewards Teams** | Export level-by-level medians across peer groups (FAANG, AI labs, FinTech, SaaS) to calibrate annual salary and RSU refresh bands. |
| **🧲 Technical Recruiters & Sourcers** | Know the exact total compensation jump between `L4 → L5` or `E5 → E6` before pitching passive candidates from Google, Meta or NVIDIA. |
| **🧑‍💻 Engineers, PMs & Designers** | Benchmark an incoming job offer against verified `medianTC`, `p75TC` and `p90TC` numbers with sample-size confidence (`levelSampleCount`). |
| **🏦 Institutional Investors & VCs** | Combine `totalCompensation` and `percentWorkforce` per level to estimate weighted-average engineering cost and SBC expense. |
| **📰 Labor Economists & Data Journalists** | Build longitudinal datasets on tech compensation across 20 job families (`software-engineer`, `product-manager`, `data-scientist`, `hardware-engineer`, `sales`, etc.). |

***

### 📥 Input configuration

All input fields are optional. Running with the prefill settings collects a fast ~20-record sample across Google, Meta and Amazon in under a minute; running with empty input (`{}`) collects a diverse ~100-record sample across top employers and roles.

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array (select) | `[]` (prefill `["google","meta","amazon"]`) | Select one or more top tech companies from the dropdown. Leave empty for a diverse multi-company sample. |
| `jobFamilies` | array (select) | `[]` (prefill `["software-engineer"]`) | Select one or more roles/job families (`software-engineer`, `product-manager`, `data-scientist`, `engineering-manager`, `product-designer`, `data-engineer`, `hardware-engineer`, etc.). |
| `location` | string (select) | `""` (All locations) | Optional metro filter (`san francisco`, `new york`, `seattle`, `london`, `bangalore`, `remote`, etc.). |
| `maxResults` | integer | `100` (prefill `20`) | Maximum compensation records to collect. Set `0` for unlimited, or `1000+` to automatically expand across roles and companies. |
| `customCompanies` | array | `[]` | Optional. Add extra companies by their Levels.fyi slug (e.g. `palantir`, `doordash`, `anthropic`, `datadog`). |
| `urls` | array | `[]` | Optional. Paste full Levels.fyi salary URLs (`https://www.levels.fyi/companies/google/salaries/software-engineer`) to scrape those exact pages. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Apify Proxy configuration. Residential proxies are recommended for consistent access. |
| `requestDelay` | integer | `2000` | Delay between page loads in milliseconds (`0`–`10000`). |

#### Input example — multi-company comp benchmark

```json
{
  "companies": ["google", "meta", "amazon", "apple", "microsoft", "nvidia", "openai", "stripe"],
  "jobFamilies": ["software-engineer", "product-manager", "data-scientist", "engineering-manager"],
  "location": "",
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "requestDelay": 1500
}
```

#### Input example — 1,000+ market-wide tech salary dataset

```json
{
  "companies": ["google", "meta", "amazon", "apple", "microsoft", "nvidia"],
  "jobFamilies": ["software-engineer", "product-manager", "data-scientist"],
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "requestDelay": 1000
}
```

#### Supported job families (roles)

`software-engineer` · `product-manager` · `data-scientist` · `product-designer` · `engineering-manager` · `data-engineer` · `solution-architect` · `hardware-engineer` · `technical-program-manager` · `information-technologist` · `business-analyst` · `security-analyst` · `sales` · `marketing` · `recruiter` · `human-resources` · `management-consultant` · `mechanical-engineer` · `accountant` · `chief-of-staff`

***

### 📤 Output & field reference

The Actor emits **one structured record per level** of each scraped company and job family. Below is a real record from a Google Software Engineer run:

```json
{
  "company": "Google",
  "companySlug": "google",
  "jobFamily": "software-engineer",
  "jobTitle": "Software Engineer",
  "level": "L5",
  "levelTitle": "L5 / Senior SWE",
  "baseSalary": 200000,
  "stockGrant": 84000,
  "bonus": 23500,
  "totalCompensation": 426881,
  "yearsOfExperience": 10,
  "yearsAtCompany": null,
  "typicalYoeMin": 9,
  "typicalYoeMax": 10,
  "percentWorkforce": 20,
  "location": "United States",
  "country": "United States",
  "offerDate": null,
  "medianTC": 426881,
  "medianBase": 200000,
  "medianStock": 84000,
  "medianBonus": 23500,
  "p10TC": 177750,
  "p25TC": 219850,
  "p75TC": 410000,
  "p90TC": 500000,
  "levelSampleCount": 57,
  "sampleCountLast12Months": 623,
  "levelBreakdown": null,
  "dataDate": "2026-10-30",
  "sourceUrl": "https://www.levels.fyi/companies/google/salaries/software-engineer",
  "scrapedAt": "2026-11-10T02:38:42.276Z"
}
```

#### 🏢 Company, Role & Level Identity

| Field | Type | Coverage | Description |
|---|---|---|---|
| `company` | string | 🟢 High (100%) | Display name of the employer (e.g. `Google`, `Meta`, `NVIDIA`). |
| `companySlug` | string | 🟢 High (100%) | URL slug on Levels.fyi (e.g. `google`, `meta`, `nvidia`). |
| `jobFamily` | string | 🟢 High (100%) | Role category slug (e.g. `software-engineer`, `product-manager`). |
| `jobTitle` | string | 🟢 High (100%) | Formatted role name or level title descriptor. |
| `level` | string | 🟢 High (~98%) | Employer level code (`L3`–`L9`, `E3`–`E9`, `SDE I`–`Principal`, `ICT2`–`ICT6`). |
| `levelTitle` | string | 🟢 High (~95%) | Combined level code and internal title (e.g. `"L5 / Senior SWE"`). |

#### 💵 Compensation & Percentile Spread (USD)

| Field | Type | Coverage | Description |
|---|---|---|---|
| `totalCompensation` | number | 🟢 High (100%) | **Per-level median total annual compensation** in USD (base + stock + bonus). |
| `baseSalary` | number | 🟢 High (~98%) | Role-level median (`p50`) annual base salary in USD. |
| `stockGrant` | number | 🟢 High (~95%) | Role-level median (`p50`) annual stock/RSU grant value in USD. |
| `bonus` | number | 🟢 High (~92%) | Role-level median (`p50`) annual target/signing bonus in USD. |
| `medianTC` | number | 🟢 High (100%) | Median total compensation (`totalCompensation` on level rows; `p50` on summary rows). |
| `medianBase` / `medianStock` / `medianBonus` | number | 🟢 High (~95%) | Role-level `p50` base salary, stock grant and bonus in USD. |
| `p10TC` / `p25TC` / `p75TC` / `p90TC` | number | 🟢 High (~95%) | 10th, 25th, 75th and 90th percentile total compensation for the role in USD. |

#### 📊 Sample Size, Experience & Metadata

| Field | Type | Coverage | Description |
|---|---|---|---|
| `levelSampleCount` | number | 🟢 High (~95%) | Number of verified compensation submissions backing this specific level's median. |
| `sampleCountLast12Months` | number | 🟢 High (~90%) | Number of compensation submissions recorded for this level in the past 12 months. |
| `percentWorkforce` | number | 🟡 Conditional (~80%) | Approximate percentage of the role's workforce at this level. |
| `typicalYoeMin` / `typicalYoeMax` | number | 🟡 Conditional (~85%) | Lower and upper bounds of typical years of experience for this level. |
| `yearsOfExperience` | number | 🟡 Conditional (~85%) | Midpoint of the typical years-of-experience band. |
| `location` / `country` | string | 🟢 High (100%) | Geographic scope of the compensation aggregate (e.g. `United States`). |
| `dataDate` | string | 🟢 High (~98%) | Date Levels.fyi last updated the aggregate statistics on the page. |
| `sourceUrl` / `scrapedAt` | string | 🟢 High (100%) | Source salary page URL and ISO 8601 extraction timestamp. |

***

### 🔁 Pagination & 1,000+ scaling

Each company and role salary page on Levels.fyi embeds the complete per-level roll-up (`6` to `10` levels per page). The Actor scales from quick 20-record benchmarks to **1,000+ compensation records** automatically:

1. **Selected pairs first**: It scrapes every `(company × jobFamily)` combination you selected (or your exact `urls`).
2. **Automatic role & company expansion**: When `maxResults` is set higher than what your initial selection produces (for example, `maxResults: 1000`), the Actor automatically expands your selected companies across all 20 job families, and then expands across a curated catalog of **100+ top technology employers** (`google`, `meta`, `amazon`, `apple`, `microsoft`, `nvidia`, `openai`, `anthropic`, `stripe`, `databricks`, `snowflake`, `palantir`, `cloudflare`, `datadog`, `citadel`, `jane-street`, etc.) until `maxResults` is reached.
3. **Zero duplicates**: Every row is deduplicated by `companySlug + jobFamily + level` before being saved to the dataset.

***

### ⚙️ How to use

1. Open **Levels.fyi Scraper** in the Apify Console and click **Try for free**.
2. Pick your target **Companies** and **Roles / Job Families** from the dropdowns (or add slugs in `customCompanies`).
3. Set **`maxResults`** (`20` for a fast test, `200` for a multi-company comparison, or `1000+` for a comprehensive market dataset).
4. Click **Start**, then export your data to **JSON, CSV, Excel, or API**.

***

### 🔌 API usage

#### Start a run via REST API

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~levels-fyi-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies": ["google", "meta", "nvidia", "openai"],
    "jobFamilies": ["software-engineer", "product-manager"],
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
  }'
```

#### Fetch dataset items in CSV format

```bash
curl "https://api.apify.com/v2/acts/haketa~levels-fyi-scraper/runs/last/dataset/items?token=YOUR_APIFY_TOKEN&format=csv"
```

***

#### Call from Python (`apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "companies": ["google", "meta", "amazon", "apple", "microsoft", "nvidia", "openai"],
    "jobFamilies": ["software-engineer", "product-manager", "data-scientist"],
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

run = client.actor("haketa/levels-fyi-scraper").call(run_input=run_input)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{row['company']} | {row['jobFamily']} | {row['level']} ({row.get('levelTitle')}) -> Median TC: ${row.get('totalCompensation'):,}")
```

#### Call from Node.js (`apify-client`)

```javascript
import { ApifyClient } from 'apify-client';

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

const run = await client.actor('haketa/levels-fyi-scraper').call({
    companies: ['google', 'meta', 'stripe', 'databricks'],
    jobFamilies: ['software-engineer', 'engineering-manager'],
    maxResults: 100,
    proxyConfiguration: {
        useApifyProxy: true,
        apifyProxyGroups: ['RESIDENTIAL'],
    },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Saved ${items.length} level compensation benchmarks`);
```

***

### 🔄 Integrations & compensation workflows

Plug **Levels.fyi Scraper** directly into your HR analytics, recruiting or investment research workflows:

| Integration | Workflow example |
|---|---|
| **📊 Google Sheets & Excel** | Maintain a live Total Rewards benchmarking workbook comparing your internal `L3`–`L8` engineering and PM bands against Google, Meta, Amazon, Apple, NVIDIA and OpenAI. |
| **❄️ Snowflake, BigQuery & Databricks** | Ingest scheduled monthly snapshots (`dataDate`, `totalCompensation`, `p25TC`, `p75TC`, `p90TC`, `levelSampleCount`, `percentWorkforce`) to track tech compensation inflation over time. |
| **⚡ Make, Zapier & n8n** | Trigger automated compensation-band alerts for your People Ops or executive recruiting team whenever target company medians shift. |
| **📈 BI Dashboards (Tableau, Looker, Power BI)** | Join `companySlug`, `jobFamily` and `level` against your ATS (Greenhouse, Lever, Workday, Ashby) offer logs to measure offer competitiveness and close rates. |
| **🤖 AI Recruiting & Negotiation Copilots** | Feed verified level medians and percentile spreads into LLM agents via Apify MCP or REST API for instant, grounded offer analysis. |

***

### ⚠️ Limitations & data notes

- **Role-level vs. per-level fields**: Levels.fyi publishes exact **total compensation (`totalCompensation`) per level** (`L3`, `L4`, `L5`, `L6`…), while reporting the component breakdown (`baseSalary`, `stockGrant`, `bonus`) and percentile spread (`p10TC`, `p25TC`, `p75TC`, `p90TC`) as role-wide aggregates (`p50`) on the company/role salary page.
- **Thinly populated roles**: For niche roles or smaller companies where Levels.fyi has too few submissions to publish a full per-level breakdown, the Actor automatically falls back to extracting the page-level percentile/median summary row so no available benchmark is lost.
- **Browser execution time**: Because each salary page is rendered in a real browser session to clear anti-bot verification cleanly, expect roughly 4–8 seconds per `company × jobFamily` page.

***

### 💡 Pro tips for compensation analysis

- **Filter by `levelSampleCount >= 10`** when building executive dashboards so every level median is backed by a statistically solid sample.
- **Compare `totalCompensation` across levels** (`L3 → L4 → L5 → L6 → L7`) to see exact promotion step-ups and equity weighting.
- **Use `p25TC` and `p75TC`** as the realistic negotiation band for a given role, and `p90TC` as the top-of-band ceiling for competing offers.
- **Keep Apify Proxy enabled** (residential recommended) so every company page clears verification smoothly.

***

### ❓ FAQ

**How many compensation records can I collect in one run?**
Each company/role page yields roughly 6–10 level rows. With automatic role and company expansion enabled, setting `maxResults: 1000` (or `0` for unlimited) collects **1,000+ unique level compensation records** across top tech employers and job families.

**Do I need a Levels.fyi account or API key?**
No. All extracted compensation aggregates come from publicly accessible Levels.fyi salary pages.

**Why are `baseSalary`, `stockGrant` and `bonus` identical across levels on the same page?**
Levels.fyi publishes **total compensation (`totalCompensation`) per level**, while exposing the base/stock/bonus breakdown (`baseSalary`, `stockGrant`, `bonus`) and percentile spread (`p10TC`–`p90TC`) at the **role** level (`p50`). Both are included on every row so you have the exact per-level total compensation alongside the role-wide component split.

**Can I scrape companies not listed in the dropdown?**
Yes. Enter any company's Levels.fyi URL slug into `customCompanies` (for example `palantir`, `doordash`, `anthropic`, `scale-ai`, `figma`, `notion`) or paste full salary URLs into `urls`.

**How do I compare leveling ladders across two or more companies (e.g. Google L5 vs. Meta E5 vs. Amazon L6)?**
Select all target companies (`["google", "meta", "amazon"]`) and your role (`["software-engineer"]`), export to CSV or Excel, and pivot on `company`, `level`, `typicalYoeMin`–`typicalYoeMax`, and `totalCompensation`. Because `typicalYoeMin`/`Max` and `percentWorkforce` are included alongside `level`, you can align cross-company levels by experience band and workforce seniority rather than guessing from title names alone.

**Can I run this scraper on an automated schedule?**
Yes. Use Apify Schedules to run the Actor weekly or monthly and send updated compensation benchmarks directly to Google Sheets, Snowflake, BigQuery, Slack or a webhook.

**What currency are compensation numbers reported in?**
All compensation fields (`totalCompensation`, `baseSalary`, `stockGrant`, `bonus`, `medianTC`, `p10TC`–`p90TC`) are normalized integers in **USD**, matching Levels.fyi's standard display currency.

#### Sample tech compensation benchmarking playbooks

| Playbook | Recommended input configuration |
|---|---|
| **🚀 FAANG+ Software Engineering L3–L8 Ladder** | `companies`: `["google", "meta", "amazon", "apple", "microsoft", "netflix", "nvidia"]`, `jobFamilies`: `["software-engineer"]`, `maxResults`: `100` |
| **🤖 AI Labs & Cloud Data Infrastructure** | `companies`: `["openai", "databricks", "snowflake", "nvidia"]`, `customCompanies`: `["anthropic", "scale-ai", "cohere"]`, `jobFamilies`: `["software-engineer", "data-scientist", "data-engineer"]`, `maxResults`: `150` |
| **💳 FinTech & Quantitative Trading Benchmarks** | `companies`: `["stripe", "coinbase"]`, `customCompanies`: `["block", "robinhood", "plaid", "citadel", "two-sigma", "jane-street"]`, `jobFamilies`: `["software-engineer", "product-manager"]`, `maxResults`: `150` |
| **🌐 1,000+ Record Cross-Industry Tech Salary Matrix** | `companies`: `["google", "meta", "amazon", "apple", "microsoft"]`, `jobFamilies`: `["software-engineer", "product-manager", "data-scientist", "engineering-manager"]`, `maxResults`: `1000` |

***

### 🔗 Related scrapers

- [Lever Jobs Scraper — Tech & Startup Job Postings](https://apify.com/haketa/lever-jobs-scraper)
- [Rippling Jobs Scraper — ATS Job Boards & Roles](https://apify.com/haketa/rippling-jobs-scraper)
- [RemoteOK Jobs Scraper — Remote Tech Jobs & Salaries](https://apify.com/haketa/remoteok-scraper)
- [FINRA BrokerCheck Scraper — Financial Advisor Profiles](https://apify.com/haketa/finra-brokercheck-scraper)
- [Hacker News Scraper — Tech Community & Hiring Threads](https://apify.com/haketa/hackernews-scraper)

***

### 📋 Changelog

- **v1.2 (2026-11)** — Unlocked **1,000+ compensation record scaling** via automatic expansion across 20 job families and 100+ top tech employers when `maxResults` exceeds initial selection; removed per-task cap when `maxResults` is set; added strict `companySlug + jobFamily + level` deduplication; tuned fast prefill (`maxResults: 20`).
- **v1.1 (2026-10)** — Upgraded per-level extraction (`faqLevels`) with `levelTitle`, `levelSampleCount`, `sampleCountLast12Months`, `percentWorkforce`, `typicalYoeMin`/`Max`, and role-wide `p10TC`–`p90TC` percentile spreads.
- **v1.0 (2026-09)** — Initial release supporting company and job-family compensation extraction from Levels.fyi.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/levels-fyi-scraper/changelog.md

# Actor input Schema

## `companies` (type: `array`):

Pick one or more companies to pull compensation data for. Leave empty to get a diverse sample of top tech employers.

## `jobFamilies` (type: `array`):

Pick which roles to include for each selected company. Leave empty for a mix of the most popular tech roles.

## `location` (type: `string`):

Optionally keep only records from a specific metro area. Leave as 'All locations' to include everything.

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

Maximum total compensation records to collect across companies and roles. Set 0 for unlimited.

## `customCompanies` (type: `array`):

Optional. Add extra companies not in the dropdown using their Levels.fyi slug, e.g. 'palantir', 'doordash'. Most users can leave this empty.

## `urls` (type: `array`):

Optional. Paste full Levels.fyi salary page URLs to scrape them directly, e.g. 'https://www.levels.fyi/companies/google/salaries/software-engineer'. When provided, the dropdown selections above are ignored.

## `proxyConfiguration` (type: `object`):

Proxy settings used to reach Levels.fyi reliably. Residential proxies are recommended.

## `requestDelay` (type: `integer`):

Delay between page loads in milliseconds. Higher values are gentler on the source site.

## Actor input object example

```json
{
  "companies": [
    "google",
    "meta",
    "amazon"
  ],
  "jobFamilies": [
    "software-engineer"
  ],
  "location": "",
  "maxResults": 20,
  "customCompanies": [],
  "urls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestDelay": 2000
}
```

# Actor output Schema

## `company` (type: `string`):

Company name

## `companySlug` (type: `string`):

Levels.fyi URL slug (e.g. google, meta)

## `jobFamily` (type: `string`):

Role category

## `jobTitle` (type: `string`):

Raw job title when present

## `level` (type: `string`):

Company level (L3-L8 etc.)

## `levelTitle` (type: `string`):

Human-readable level title(s), e.g. 'L5 / Senior SWE'

## `baseSalary` (type: `string`):

Annual base salary (USD)

## `stockGrant` (type: `string`):

Annual RSU/equity (USD)

## `bonus` (type: `string`):

Annual bonus (USD)

## `totalCompensation` (type: `string`):

Total annual comp (USD)

## `location` (type: `string`):

City/region

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

Country when Levels.fyi exposes it separately

## `offerDate` (type: `string`):

Submission/offer date as reported by Levels.fyi

## `yearsOfExperience` (type: `string`):

Years of experience

## `yearsAtCompany` (type: `string`):

Years at the listed company

## `typicalYoeMin` (type: `string`):

Lower bound of typical years of experience for this level

## `typicalYoeMax` (type: `string`):

Upper bound of typical years of experience for this level

## `percentWorkforce` (type: `string`):

Approximate share of the workforce at this level

## `sourceUrl` (type: `string`):

Levels.fyi page URL

## `scrapedAt` (type: `string`):

ISO timestamp

## `medianTC` (type: `string`):

Salary percentile/median stat

## `medianBase` (type: `string`):

Salary percentile/median stat

## `medianStock` (type: `string`):

Salary percentile/median stat

## `medianBonus` (type: `string`):

Salary percentile/median stat

## `p10TC` (type: `string`):

Salary percentile/median stat

## `p25TC` (type: `string`):

Salary percentile/median stat

## `p75TC` (type: `string`):

Salary percentile/median stat

## `p90TC` (type: `string`):

Salary percentile/median stat

## `levelSampleCount` (type: `string`):

Number of crowdsourced submissions behind this level's median

## `sampleCountLast12Months` (type: `string`):

Submissions reported for this level in the last 12 months

## `dataDate` (type: `string`):

Date Levels.fyi last refreshed the aggregates for this page

# 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 = {
    "companies": [
        "google",
        "meta",
        "amazon"
    ],
    "jobFamilies": [
        "software-engineer"
    ],
    "maxResults": 20,
    "customCompanies": [],
    "urls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/levels-fyi-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 = {
    "companies": [
        "google",
        "meta",
        "amazon",
    ],
    "jobFamilies": ["software-engineer"],
    "maxResults": 20,
    "customCompanies": [],
    "urls": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/levels-fyi-scraper").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 '{
  "companies": [
    "google",
    "meta",
    "amazon"
  ],
  "jobFamilies": [
    "software-engineer"
  ],
  "maxResults": 20,
  "customCompanies": [],
  "urls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/levels-fyi-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/levels-fyi-scraper"
        }
    }
}
```

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/Ir4tpKKKSZllWue2D/builds/fujcYSpGqI37Ee5Fz/openapi.json