# Indeed Job Search Scraper with Salary & Benefits Data (`vexaloom-labs/indeed-job-search-scraper-with-salary-and-benefits`) Actor

Search Indeed by keyword and location, or supply direct Indeed search URLs, and get job titles, salaries, company ratings, benefits, remote-work status, and more. No login or API key needed.

- **URL**: https://apify.com/vexaloom-labs/indeed-job-search-scraper-with-salary-and-benefits.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Indeed Job Search Scraper with Salary & Benefits Data

Turn any Indeed job search into a structured, analysis-ready dataset. Give it keywords, a location and optional filters — or paste search, company or single-job URLs — and receive each posting with its full description, salary range and pay period, benefits, remote-work model, employer details and the link candidates actually apply through. No Indeed account, cookie or API key required.

### What this actor does

- **Search 62 country sites** by keyword and location, with filters for date posted, job type, workplace, experience, education, Easy Apply and minimum salary
- **Paste Indeed URLs** — filtered search links, company job pages (`/cmp/<company>/jobs`) and individual job links are all understood, and filters in a URL are honored
- **Full descriptions, not teasers** — every listing carries the complete posting text, with optional HTML
- **Structured compensation** — minimum, maximum, period, currency, annualized figures, and whether the range is the employer's own
- **Employer and application data** — company size, revenue, industry, CEO and website when Indeed holds them, plus the external application link for off-site applications
- **Beyond Indeed's search ceiling** — Indeed stops each query at roughly 600–900 unique jobs; the actor automatically splits the search into date windows and merges them, returning the full set Indeed's index holds for your query
- **Optional employer depth** — add sub-ratings, Work-Wellbeing, CEO details, salary-by-title reports and full review pages for each hiring company
- **Clean records** — duplicates across searches are removed by job key, and fields Indeed has no value for are left out of the record instead of being padded with blanks

### Output per job

Identity

- `jobKey` — Indeed's stable job identifier
- `jobTitle`, `normalizedTitle` — title as published and Indeed's normalized form
- `company`, `companyId`, `companyUrl`, `companyLogo`
- `source`, `language`

Location

- `location` — formatted location as Indeed shows it
- `city`, `state`, `stateName`, `county`, `postalCode`, `streetAddress`, `neighborhood`
- `countryCode`, `countryName`
- `latitude`, `longitude`

Compensation

- `salaryText` — salary as displayed
- `salaryMin`, `salaryMax`, `salaryType`, `salaryCurrency`
- `salarySource` — `EMPLOYER` for the employer's own range, `INDEED_ESTIMATE` when Indeed's estimate is used
- `salaryAnnualMin`, `salaryAnnualMax` — hourly, daily, weekly and monthly pay converted to a yearly figure

Classification

- `jobTypes` (JSON string) and `jobTypesList` (array) — employment types
- `benefits` (JSON string) and `benefitsList` (array) — listed benefits
- `employmentType`, `schedules`, `payTypes`
- `workplaceType` — Remote / Hybrid / In-person / Office
- `remoteWork` — Indeed's raw model value (`REMOTE_ALWAYS`, `REMOTE_HYBRID`, `ON_SITE`)
- `experienceLevel`, `educationLevels`, `attributes`, `occupations`

Description and dates

- `description`, `descriptionHtml` (when requested), `snippet`
- `datePosted`, `datePublished` — ISO 8601 timestamps
- `validThrough`, `isExpired`, `postedTime`

Application

- `indeedApply` — accepts Indeed's one-click application
- `applyUrl` — the employer's own application link, when it differs from Indeed
- `urgentlyHiring`, `highVolumeHiring`

Company profile (when Indeed holds it)

- `companyDescription`, `companySize`, `companyRevenue`, `companyIndustry`
- `companyCeo` (the dossier name), `companyHeadquarters`
- `companyRating`, `companyReviewCount` — from Indeed's data; the optional ratings lookup adds:
  - `companyRatings` — work-life balance, pay and benefits, job security, management, culture
  - `companyRatingTrend` — yearly rating history
  - `companyWorkWellbeing` — Indeed's Work-Wellbeing score with its sub-scores
  - `companyCeoName`, `companyCeoPhotoUrl`, `companyCeoApproval`, `companyFounded`
  - `companySalaries` — average pay by job title (what Indeed reports)
  - `companyReviewSnippets` — up to five recent review excerpts
- `companyReviews` — up to 20 full first-page reviews with pros/cons and sub-ratings, plus `companyReviewsFound` and `companyReviewsTotal` (reviews toggle)
- `companySalaryTotal` and `companySalarySatisfaction` — salary reports count and satisfaction ratio (salaries toggle)

Contacts (optional)

- `emails`, `phoneNumbers` — patterns written in the posting's own description text; not an Indeed contact field

Provenance

- `searchQuery`, `searchLocation`, `country`
- `recordType`, `scrapeTimestamp`

Sample record:

```json
{
  "jobKey": "2f2c680351b7c737",
  "jobTitle": "Senior Software Engineer (AI Products)",
  "company": "Brillian",
  "companyUrl": "https://www.indeed.com/cmp/Brillian",
  "location": "New York, NY",
  "city": "New York",
  "state": "NY",
  "countryCode": "US",
  "latitude": 40.71427,
  "longitude": -74.00597,
  "salaryText": "$200,000 - $240,000 a year",
  "salaryMin": 200000,
  "salaryMax": 240000,
  "salaryType": "YEARLY",
  "salaryCurrency": "USD",
  "salarySource": "EMPLOYER",
  "salaryAnnualMin": 200000,
  "salaryAnnualMax": 240000,
  "jobTypesList": ["Full-time"],
  "benefitsList": ["Health insurance", "Dental insurance", "401(k)", "Vision insurance"],
  "workplaceType": "Hybrid",
  "experienceLevel": "Senior level",
  "description": "About Our Company …",
  "datePosted": "2026-06-10T14:24:55Z",
  "applyUrl": "https://ats.example.com/careers/job/12345",
  "jobUrl": "https://www.indeed.com/viewjob?jk=2f2c680351b7c737",
  "recordType": "job",
  "scrapeTimestamp": "2026-10-17T08:16:48Z"
}
```

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | – | Job searches. Put a location after " in ": `data analyst in Austin, TX`. A query without " in " uses `location`, or searches the whole country |
| `startUrls` | array | – | Indeed URLs: filtered searches, `https://www.indeed.com/cmp/Google/jobs`, or job links with `jk=` |
| `country` | string | `US` | Indeed country site to search (62 available). Salaries come back in that country's currency and job links point to the matching site; URL tasks from other country sites work too |
| `location` | string | – | City, region or postal code for searches that don't name one. Ignored for remote-only searches |
| `radius` | integer | `25` | Search distance from the location (0–500) |
| `radiusUnit` | string | `miles` | `miles` or `kilometers` |
| `sort` | string | `relevance` | `relevance` or `date` (newest first) |
| `datePosted` | string | – | Only jobs posted within 1, 3, 7, 14 or 30 days |
| `jobType` | string | – | Full-time, part-time, contract, temporary, internship, permanent, seasonal, per diem, freelance, apprenticeship or volunteer |
| `workplaceType` | string | – | `remote`, `hybrid` or `inPerson` |
| `experienceLevel` | string | – | `noExperience`, `entry`, `mid` or `senior` |
| `educationLevel` | string | – | `noDegree`, `highSchool`, `associate`, `bachelor`, `master` or `doctoral` |
| `easyApplyOnly` | boolean | `false` | Only jobs accepting Indeed's one-click application |
| `salaryMin` | integer | – | Only jobs paying at least this much per year, comparing annualized pay. Jobs with no stated salary are kept |
| `maxItems` | integer | `50` | Overall cap across all searches (1–10000) |
| `maxItemsPerSearch` | integer | – | Cap per search query or URL; defaults to `maxItems` |
| `includeDescriptionHtml` | boolean | `false` | Also save each description as HTML |
| `includeCompanyRatings` | boolean | `false` | Look up employer ratings plus sub-ratings, wellbeing, CEO details, salary-by-title reports and review snippets for each unique hiring company |
| `includeContacts` | boolean | `false` | Extract emails and phone numbers written in the posting description |
| `includeCompanyReviews` | boolean | `false` | Also fetch the first page of each employer's reviews: up to 20 full reviews (one extra request per company) |
| `includeCompanySalaries` | boolean | `false` | Also fetch each employer's salaries page: total report count, satisfaction and the broader title list (one extra request per company) |
| `expandBeyondCeiling` | boolean | `true` | Bypass Indeed's ~600–900-result search ceiling by splitting the search's date range into windows and merging the slices; narrow searches are unaffected |

At least one search query or URL is needed — or a filter plus a country.

#### Example: recent remote roles

```json
{
  "searchQueries": ["customer success manager"],
  "country": "US",
  "workplaceType": "remote",
  "datePosted": "7",
  "maxItems": 200
}
```

#### Example: salaries in Germany

```json
{
  "searchQueries": ["Softwareentwickler in Berlin"],
  "country": "DE",
  "salaryMin": 70000,
  "maxItems": 100
}
```

#### Example: a filtered URL and a company page

```json
{
  "startUrls": [
    "https://www.indeed.com/jobs?q=nurse&l=Chicago%2C+IL&sc=0kf%3Ajt%28fulltime%29%3B&fromage=7",
    "https://www.indeed.com/cmp/Amazon/jobs"
  ],
  "maxItems": 300
}
```

#### Example: fetch specific job links

```json
{
  "startUrls": [
    "https://www.indeed.com/viewjob?jk=2f2c680351b7c737",
    "7d7746167b22c122"
  ],
  "includeDescriptionHtml": true
}
```

### Use cases

- **Salary benchmarking** — build numeric pay ranges by title, city and country, with annualized values ready to chart
- **Remote-work research** — measure how much of a role is remote, hybrid or on-site
- **Recruiting intelligence** — track which employers are hiring for a skill, where, and at what pay
- **Job-board operators** — republish fresh listings with company and benefit data on your own board
- **Labour-market studies** — analyse posting volumes by date window, experience level and education
- **Lead generation** — companies hiring for a role are buying related services; export them with websites and locations

### FAQ

#### Do I need an Indeed account or API key?

No. The actor reads Indeed's publicly available job data without any login, cookie or key.

#### How many jobs can one search return?

Indeed's own ranking ends one query after roughly 600–900 unique jobs. With `expandBeyondCeiling` on (the default), the actor splits the search into date windows and merges them: a live test returned 2,599 unique jobs for a query whose single pass stopped at 861. It stops at the size of Indeed's app index for your query — which can be smaller than Indeed's web page count — and older than two years is not covered. Narrow searches (fewer than ~750 results) are handled in a single pass. A job found by more than one search or window is saved once — every posting has one `jobKey`.

#### Why is the applicant count missing?

Indeed does not expose applicant numbers through its public job data; the only counter is an internal tracking value on its web search page without the displayed meaning. The actor therefore does not ship an applicant field. Posting age (`datePosted`, `postedTime`) is included.

#### Why do email/phone fields only appear sometimes?

They are extracted from text employers wrote in the posting, because Indeed's job data does not carry recruiter contacts. About one posting in nine includes an email. Enable `includeContacts` to add them.

#### Why do Indeed links return 403 to my link checker?

Indeed protects its own pages with Cloudflare bot management. `jobUrl` and `companyUrl` open normally in a browser, but a clean command-line request or a datacenter connection receives 403 — sometimes a login redirect — and that is expected, not a broken URL. From an ordinary residential browser session Indeed's `/job/` pages and its apply redirects do open. `applyUrl` points directly at the employer's own application page whenever they apply off-site; those links are served raw and are machine-reachable, though a small share are dead because the employer removed the posting.

#### Why is the salary missing on some jobs?

Many employers simply do not publish pay. Those listings have no salary fields rather than a guessed number. Indeed's own estimated pay is rendered only on its login-gated pages, so the actor ships the employer's stated salary and never substitutes an estimate; `salarySource` is `EMPLOYER` whenever a range exists.

#### Why do some company fields look empty?

Indeed only holds company profiles for employers that maintain one. Fields like revenue, CEO or founded year are omitted when Indeed has no value, instead of being sent as blanks.

#### What is the difference between `indeedApply` and `applyUrl`?

`indeedApply: true` means the posting accepts Indeed's one-click application. `applyUrl` is the employer's own application page — an ATS or career site — which is what you follow for off-site applications.

#### Will the actor get blocked?

The actor reads Indeed data through the same interface Indeed's own mobile app uses, and picks a working connection automatically. If a search cannot be loaded at all, the run says so in its status message rather than returning empty records silently.

#### Is this affiliated with Indeed?

No. This is an independent, third-party actor that reads Indeed's public job data; it is not operated by or affiliated with Indeed.

# Actor input Schema

## `searchQueries` (type: `array`):

Job searches. Write a location after " in " to search one city, e.g. `software engineer in New York`, `registered nurse in Houston, TX`. A query without " in " uses the Location field below, or searches the whole country.

## `startUrls` (type: `array`):

Indeed pages to scrape: filtered search URLs (filters in the URL are honored), company job pages like `https://www.indeed.com/cmp/Google/jobs`, or individual job links like `https://www.indeed.com/viewjob?jk=...`. Country sites such as `uk.indeed.com` work too.

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

Indeed country site to search. Results come in the site's language and salaries in its currency.

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

City, region or postal code for searches that don't name a location themselves, e.g. `Austin, TX`, `10001`, `London`. Leave empty to search the whole country. Ignored for remote-only searches (remote jobs are searched country-wide).

## `radius` (type: `integer`):

How far from the location to search.

## `radiusUnit` (type: `string`):

Unit for the search radius.

## `sort` (type: `string`):

How to order results: by relevance to the keywords, or with the newest postings first.

## `datePosted` (type: `string`):

Only jobs posted within this window.

## `jobType` (type: `string`):

Only jobs of this employment type.

## `workplaceType` (type: `string`):

Remote, hybrid or on-site jobs only. Remote searches run country-wide because Indeed's app index does not geo-attribute remote jobs.

## `experienceLevel` (type: `string`):

Only jobs asking for this experience level.

## `educationLevel` (type: `string`):

Only jobs asking for this education level.

## `easyApplyOnly` (type: `boolean`):

Only jobs that accept Indeed's one-click application.

## `salaryMin` (type: `integer`):

Only jobs paying at least this much per year (employer-stated salaries; hourly and monthly pay is compared at its annualized value). Jobs without a stated salary are kept.

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

Maximum number of job listings to save across all searches.

## `maxItemsPerSearch` (type: `integer`):

Optional cap per search query or URL. Defaults to the overall Maximum jobs value.

## `includeDescriptionHtml` (type: `boolean`):

Also save each job description as HTML next to the plain text.

## `includeCompanyRatings` (type: `boolean`):

Look up each employer's Indeed rating and review count. Off by default; a rating that cannot be read is left out of the record.

## `includeContacts` (type: `boolean`):

Extract email addresses and phone numbers written in the posting's own description text (pattern extraction, not an Indeed field). Off by default.

## `includeCompanyReviews` (type: `boolean`):

Fetch the first page of each employer's Indeed reviews (up to 20 full reviews with pros/cons and sub-ratings); combine with Include company ratings. Off by default.

## `includeCompanySalaries` (type: `boolean`):

Fetch each employer's Indeed salaries page (total salary reports, satisfaction and the broader salary-by-title list); combine with Include company ratings. Off by default.

## `expandBeyondCeiling` (type: `boolean`):

Indeed's app search stops at roughly 600-900 unique jobs per query. When a search reaches that ceiling, split its time range into date windows and merge them, so the run returns the full set Indeed's index holds for the query. Narrow searches are handled in a single pass.

## Actor input object example

```json
{
  "searchQueries": [
    "web developer in San Francisco"
  ],
  "country": "US",
  "location": "San Francisco",
  "radius": 25,
  "radiusUnit": "miles",
  "sort": "relevance",
  "datePosted": "",
  "jobType": "",
  "workplaceType": "",
  "experienceLevel": "",
  "educationLevel": "",
  "easyApplyOnly": false,
  "maxItems": 3,
  "includeDescriptionHtml": false,
  "includeCompanyRatings": false,
  "includeContacts": false,
  "includeCompanyReviews": false,
  "includeCompanySalaries": false,
  "expandBeyondCeiling": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

Dataset containing all scraped Indeed job listings.

# 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 = {
    "searchQueries": [
        "web developer in San Francisco"
    ],
    "country": "US",
    "location": "San Francisco",
    "radius": 25,
    "easyApplyOnly": false,
    "maxItems": 3,
    "includeDescriptionHtml": false,
    "includeCompanyRatings": false,
    "includeContacts": false,
    "includeCompanyReviews": false,
    "includeCompanySalaries": false,
    "expandBeyondCeiling": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/indeed-job-search-scraper-with-salary-and-benefits").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 = {
    "searchQueries": ["web developer in San Francisco"],
    "country": "US",
    "location": "San Francisco",
    "radius": 25,
    "easyApplyOnly": False,
    "maxItems": 3,
    "includeDescriptionHtml": False,
    "includeCompanyRatings": False,
    "includeContacts": False,
    "includeCompanyReviews": False,
    "includeCompanySalaries": False,
    "expandBeyondCeiling": False,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/indeed-job-search-scraper-with-salary-and-benefits").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 '{
  "searchQueries": [
    "web developer in San Francisco"
  ],
  "country": "US",
  "location": "San Francisco",
  "radius": 25,
  "easyApplyOnly": false,
  "maxItems": 3,
  "includeDescriptionHtml": false,
  "includeCompanyRatings": false,
  "includeContacts": false,
  "includeCompanyReviews": false,
  "includeCompanySalaries": false,
  "expandBeyondCeiling": false
}' |
apify call vexaloom-labs/indeed-job-search-scraper-with-salary-and-benefits --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/indeed-job-search-scraper-with-salary-and-benefits"
        }
    }
}
```

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/RXu7Xe475tOdKeSaK/builds/sqbMLB30NaUVc43cb/openapi.json