# Indeed Jobs Scraper Pro: Search, Salaries & Company Intel (`scrapemint/indeed-jobs-scraper`) Actor

Scrape Indeed jobs from keywords, search URLs, job IDs, or company pages. Each row ships parsed salary, skills, seniority tier, remote/hybrid signal, Easy Apply flag, sponsored flag, optional company enrichment. 18 countries. Pay per row.

- **URL**: https://apify.com/scrapemint/indeed-jobs-scraper.md
- **Developed by:** [Kennedy Mutisya](https://apify.com/scrapemint) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Indeed Jobs Scraper Pro: Search, Salaries & Company Intel

Scrape Indeed jobs from keywords, search URLs, direct job IDs, or company pages. Each row ships parsed salary, skills, seniority tier, remote/hybrid signal, Easy Apply flag, sponsored flag, and optional company enrichment with rating, reviews, size, industry, and founded year. 18 countries. Pay per row.

**Built for** sales teams sourcing leads at hiring companies, recruiters benchmarking salary bands, talent acquisition tracking competitor reqs, market research firms watching hiring trends, BI teams piping job market data into a warehouse, and lead-gen platforms enriching company records with active req counts.

**Keywords this actor ranks for:** indeed scraper, indeed jobs scraper, indeed scraper api, indeed job listings, indeed salary scraper, indeed company scraper, indeed jobs to JSON, indeed lead finder, hiring intent signals, recruiting intelligence, job board scraper, indeed scraping tool.

---

### Why this actor

| Other Indeed scrapers | **This actor** |
|---|---|
| Single search URL input | Four input modes: keywords + locations, search URLs, direct job IDs, company pages |
| Title and link only | Parsed salary into min, max, period, currency, and normalized annual estimate |
| No skills detection | 200+ tech and business skills detected from the description |
| US only | 18 countries with proper regional domains |
| No seniority tagging | Auto classified into intern, entry, mid, senior, lead, principal, staff, manager, director, vp, c level |
| No remote signal | Parses location and description to flag remote, hybrid, or on site |
| No company enrichment | Optional company rating, review count, size band, industry, founded year |
| Sponsored mixed with organic | Sponsored vs organic flag on every row |
| Single nationwide search | Optional split by city across the country's top metros for high volume runs |

---

### How it works

```mermaid
flowchart LR
    A[Keywords + Locations<br/>Search URLs<br/>Job IDs<br/>Company URLs] --> B[Listing crawl<br/>cards + filters + paginate]
    A --> C[Direct viewjob<br/>per job ID]
    B --> C
    C --> D[Detail page<br/>Playwright + Apify residential]
    D --> E[Parse salary skills<br/>seniority remote easy apply]
    E --> F[Optional company page<br/>rating reviews size industry]
    F --> G[One row per job]
    G --> H[(JSON CSV API)]
````

Pages render with Playwright behind rotating residential proxy with browser fingerprinting and per-session homepage warmup. Cloudflare interstitials resolve automatically.

***

### What you get per row

```mermaid
flowchart LR
    R[Job row] --> R1[Identity<br/>jobId url country]
    R --> R2[Title + seniority<br/>employment type]
    R --> R3[Company<br/>name rating reviews]
    R --> R4[Location<br/>text + remote hybrid onsite]
    R --> R5[Compensation<br/>min max period currency annual]
    R --> R6[Skills<br/>200+ detected]
    R --> R7[Flags<br/>sponsored easyApply urgent]
    R --> R8[Apply link<br/>external + resolved]
    R --> R9[Description + benefits<br/>posted date + length]
```

Toggle on `scrapeCompanyDetails` and the run also pushes one company row per unique employer with rating, review count, size band, industry, founded year, headquarters, revenue, and website.

***

### Quick start

**Search keywords across multiple locations**

```json
{
  "keywords": ["software engineer", "data engineer"],
  "locations": ["New York, NY", "Boston, MA", "Remote"],
  "country": "US",
  "maxJobs": 200,
  "datePosted": "7",
  "remoteFilter": "remote"
}
```

**Direct job IDs for fast lookup**

```json
{
  "jobIds": ["abc123def456", "789ghi012jkl"],
  "country": "US",
  "scrapeCompanyDetails": true
}
```

**Track a single company's catalog**

```json
{
  "companyUrls": ["https://www.indeed.com/cmp/Anthropic"],
  "maxJobs": 50,
  "extractSkills": true,
  "scrapeCompanyDetails": true
}
```

**Multi country (UK + Germany + India)**

```json
{
  "keywords": ["product manager"],
  "country": "GB",
  "locations": ["London", "Manchester"],
  "maxJobs": 100,
  "datePosted": "14",
  "scrapeCompanyDetails": true
}
```

**Nationwide split across top US cities**

```json
{
  "keywords": ["machine learning engineer"],
  "country": "US",
  "splitByCity": true,
  "maxJobs": 500,
  "remoteFilter": "any",
  "minSalary": 150000
}
```

***

### Sample output

```json
{
  "jobId": "abc123def456",
  "url": "https://www.indeed.com/viewjob?jk=abc123def456",
  "country": "US",
  "title": "Senior Product Manager, AI Platform",
  "company": {
    "name": "Anthropic",
    "indeedUrl": "https://www.indeed.com/cmp/Anthropic",
    "slug": "Anthropic",
    "ratingStars": 4.6,
    "reviewCount": 142
  },
  "location": {
    "text": "San Francisco, CA · Hybrid",
    "workMode": "hybrid"
  },
  "employment": {
    "type": "fulltime",
    "seniority": "senior"
  },
  "compensation": {
    "rawText": "$220,000 - $280,000 a year",
    "currency": "USD",
    "period": "year",
    "min": 220000,
    "max": 280000,
    "annualEstimate": 280000,
    "isEstimated": false,
    "isListed": true
  },
  "flags": {
    "sponsored": false,
    "easyApply": true,
    "urgentlyHiring": false
  },
  "applyLink": {
    "external": "https://anthropic.com/careers/...",
    "resolved": null
  },
  "skills": ["python", "sql", "saas", "b2b", "product management", "agile", "okrs"],
  "benefitsText": "401(k), Health insurance, Paid time off",
  "descriptionLength": 4128,
  "postedDateText": "3 days ago",
  "postedDate": "2026-04-24T18:22:00.000Z",
  "searchContext": {
    "keyword": "product manager",
    "location": "San Francisco, CA"
  },
  "scrapedAt": "2026-04-27T18:00:00.000Z"
}
```

***

### Who uses this

| Role | Use case |
|---|---|
| Sales / lead gen | Companies hiring SDRs, AEs, or marketers signal growth. Build prospect lists from active reqs. |
| Recruiter | Watch competitor reqs. Salary benchmarking by title and city. |
| Talent acquisition | Track who is hiring for the same roles you are. Adjust comp bands monthly. |
| Market researcher | Hiring pulse by industry, region, and seniority tier. Top-down growth signal. |
| BI / data team | Pipe job catalog into Snowflake or BigQuery. Each row API ready. |
| Career coach | Salary calibration for clients across cities and titles. |
| Recruitment agency | Source candidates by detecting urgent hires and Easy Apply jobs. |

***

### Input reference

| Field | Type | What it does |
|---|---|---|
| `keywords` | string\[] | Position or skill keywords. |
| `locations` | string\[] | Cities, states, countries. Cartesian product with keywords. |
| `country` | enum | 18 country domains. |
| `searchUrls` | string\[] | Paste any Indeed search URL directly. |
| `jobIds` | string\[] | Direct jk= IDs. Fastest input mode. |
| `companyUrls` | string\[] | Indeed `/cmp/...` URLs. |
| `maxJobs` | integer | Cap on jobs across all queries. |
| `datePosted` | enum | any, 1, 3, 7, 14 days. |
| `jobType` | enum | fulltime, parttime, contract, temporary, internship. |
| `experienceLevel` | enum | entry\_level, mid\_level, senior\_level. |
| `remoteFilter` | enum | remote, hybrid, onsite. |
| `minSalary` | integer | Minimum salary in local currency. |
| `radius` | integer | Search radius in miles (0, 5, 10, 15, 25, 50, 100). |
| `splitByCity` | boolean | Fan a nationwide search across top metros. |
| `scrapeCompanyDetails` | boolean | Pull rating, reviews, size, industry, founded year per company. |
| `extractSkills` | boolean | Detect 200+ tech and business skills. |
| `parseSalary` | boolean | Convert salary text into structured fields. |
| `classifySeniority` | boolean | Tag intern through C level. |
| `detectEasyApply` | boolean | Flag Indeed Easy Apply jobs. |
| `detectRemoteHybrid` | boolean | Set workMode based on location and description. |
| `followApplyRedirect` | boolean | Resolve external Apply URL through Indeed's redirect chain. |
| `dedupe` | boolean | Skip job IDs from previous runs. |
| `concurrency` | integer | Parallel pages. Three to five is safe. |
| `proxyConfiguration` | object | Apify proxy. Residential is required for Indeed. |

***

### API call

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_USER~indeed-jobs-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["data engineer"],
    "locations": ["San Francisco, CA", "Remote"],
    "country": "US",
    "maxJobs": 100,
    "datePosted": "7",
    "scrapeCompanyDetails": true
  }'
```

***

### Pricing

The first few jobs per run are free so you can validate the output before paying. After that, one charge per job row. Skills detection, seniority classification, salary parsing, and remote signal are all included at no extra cost. Company enrichment adds one charge per unique company.

***

### FAQ

#### What is the difference between this and the official Indeed Publisher API?

Indeed sunset the public Publisher API in 2023. The current options are unofficial scraping or partner-tier deals at $100K+ per year. This actor reads HTML any anonymous web visitor sees, with no key required, no quota, and 18 country domains.

#### Why does Indeed block scrapers?

Indeed sits behind Cloudflare with aggressive bot detection. The actor uses fingerprinted Chrome with rotating residential proxies, per-session homepage warmup, and Cloudflare interstitial resolution. Most challenges resolve within two retries.

#### Can I scrape salaries that Indeed estimates?

Yes. The `compensation.isListed` flag tells you whether the employer listed the salary or whether Indeed estimated it. Both ship with min, max, period, currency, and a normalized annual estimate.

#### How accurate is the seniority classifier?

Title based, deterministic, eleven tiers. Catches "Sr.", "Jr.", "Lead", "Staff", "Principal", "Manager", "Director", "VP", "Head of", "Chief" patterns plus localized variants. False positives are rare; misses come from unusual title styles.

#### Does it handle multi country searches?

Yes. Pass any of 18 country codes and the actor switches to that regional domain (uk.indeed.com, de.indeed.com, in.indeed.com, etc.). Salary parsing detects the local currency automatically.

#### Can it pull every job from a single company?

Yes. Pass the company's Indeed `/cmp/CompanyName` URL in `companyUrls`. The actor walks the company's job list and returns every posting up to `maxJobs`.

#### What is the splitByCity option?

Indeed caps each search at about 1000 results. For large nationwide pulls, enable `splitByCity` and the actor expands the query across the country's top metro areas, multiplying total reach.

#### Is Indeed scraping legal?

This actor reads HTML any anonymous web visitor can see. Respect Indeed's terms and rate limit sensibly. Do not use scraped contact info for unsolicited messaging in jurisdictions where that violates law.

***

### Related actors

- **LinkedIn Jobs Scraper Pro & Recruiter Contacts**. Search URL, company URL, and recruiter contact extraction.
- **HackerNews Lead Monitor**. Alerts for hiring threads matching your skills.
- **Upwork Opportunity Alert**. Live alerts for new freelance jobs matching your stack.
- **Stack Overflow Lead Monitor**. Detect technical questions from buyers in your niche.
- **Website Content Crawler**. Companies websites to clean Markdown with token counts.
- **Amazon Product Scraper**. Product catalog for ecommerce ops teams.

# Actor input Schema

## `keywords` (type: `array`):

Position or keyword strings. Each runs an independent search and combines with locations. Leave blank if you are passing searchUrls or jobIds directly.

## `locations` (type: `array`):

Cities, states, postal codes, or country names. Each combines with each keyword (cartesian product). Leave blank for nationwide searches.

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

Indeed regional domain. Affects which jobs are surfaced. 18 countries supported.

## `searchUrls` (type: `array`):

Paste any Indeed search URL. Filters and pagination are extracted automatically. Mix with keywords or use exclusively.

## `jobIds` (type: `array`):

Indeed job IDs from the jk= URL param. Skips the listing crawl entirely. Fastest input mode.

## `companyUrls` (type: `array`):

URLs to Indeed company pages (https://www.indeed.com/cmp/...). Pulls every job posted on that company page up to maxJobs.

## `maxJobs` (type: `integer`):

Hard cap on jobs returned across all queries. Indeed paginates 15 jobs per page. Set 0 for everything Indeed exposes.

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

Filter by recency. Maps to Indeed's fromage param.

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

Filter by employment type.

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

Filter by Indeed experience tag.

## `remoteFilter` (type: `string`):

Filter by work location type.

## `minSalary` (type: `integer`):

Minimum salary in the local currency. Indeed often estimates salaries when the employer does not list one.

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

Distance from the location in miles. 0 means exact match. 25 is Indeed's default. Common values: 5, 10, 15, 25, 50, 100.

## `splitByCity` (type: `boolean`):

When you want lots of jobs from a country, Indeed caps each search at about 1000 results. Enable this to fan the search out across the country's top metro areas.

## `scrapeCompanyDetails` (type: `boolean`):

Fetch each unique company's Indeed page and enrich rows with rating, total reviews, size band, industry, and founded year. Pushed as a separate dataset row per company.

## `extractSkills` (type: `boolean`):

Detect mentioned skills in the job description (200+ tech and business skills, multi language).

## `parseSalary` (type: `boolean`):

Convert salary text into min, max, period, currency, and a normalized annual estimate. Distinguishes employer listed from Indeed estimated.

## `classifySeniority` (type: `boolean`):

Tag each job as intern, entry, mid, senior, lead, principal, staff, manager, director, vp, or c level based on title.

## `detectEasyApply` (type: `boolean`):

Flag jobs that use Indeed's one click Easy Apply (vs employer redirect).

## `detectRemoteHybrid` (type: `boolean`):

Parse the location field and description for remote, hybrid, or on site work signals. Sets a workMode field on every row.

## `followApplyRedirect` (type: `boolean`):

Resolve the final Apply URL by following Indeed's redirect chain. Returns the employer's external ATS URL when present. Adds latency.

## `dedupe` (type: `boolean`):

Skip job IDs already pushed in previous runs. Turn off to refresh stale rows.

## `concurrency` (type: `integer`):

Number of pages processed in parallel. Three to five is safe. Higher values trigger Cloudflare challenges.

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

Apify proxy. Residential is required for Indeed at any meaningful volume. Datacenter is blocked within minutes.

## Actor input object example

```json
{
  "keywords": [
    "product manager"
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "country": "US",
  "searchUrls": [],
  "jobIds": [],
  "companyUrls": [],
  "maxJobs": 25,
  "datePosted": "any",
  "jobType": "any",
  "experienceLevel": "any",
  "remoteFilter": "any",
  "minSalary": 0,
  "radius": 25,
  "splitByCity": false,
  "scrapeCompanyDetails": false,
  "extractSkills": true,
  "parseSalary": true,
  "classifySeniority": true,
  "detectEasyApply": true,
  "detectRemoteHybrid": true,
  "followApplyRedirect": false,
  "dedupe": true,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "keywords": [
        "product manager"
    ],
    "locations": [
        "San Francisco, CA"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/indeed-jobs-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 = {
    "keywords": ["product manager"],
    "locations": ["San Francisco, CA"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/indeed-jobs-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 '{
  "keywords": [
    "product manager"
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapemint/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper Pro: Search, Salaries & Company Intel",
        "description": "Scrape Indeed jobs from keywords, search URLs, job IDs, or company pages. Each row ships parsed salary, skills, seniority tier, remote/hybrid signal, Easy Apply flag, sponsored flag, optional company enrichment. 18 countries. Pay per row.",
        "version": "0.1",
        "x-build-id": "z7Mh371mRbZvZTtYS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-indeed-jobs-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/scrapemint~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-indeed-jobs-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/scrapemint~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-indeed-jobs-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": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Position or keyword strings. Each runs an independent search and combines with locations. Leave blank if you are passing searchUrls or jobIds directly.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, states, postal codes, or country names. Each combines with each keyword (cartesian product). Leave blank for nationwide searches.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "IE",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "BE",
                            "IN",
                            "JP",
                            "SG",
                            "BR",
                            "MX",
                            "ZA",
                            "AE"
                        ],
                        "type": "string",
                        "description": "Indeed regional domain. Affects which jobs are surfaced. 18 countries supported.",
                        "default": "US"
                    },
                    "searchUrls": {
                        "title": "Direct search URLs (alternative input)",
                        "type": "array",
                        "description": "Paste any Indeed search URL. Filters and pagination are extracted automatically. Mix with keywords or use exclusively.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobIds": {
                        "title": "Direct job IDs (jk parameter)",
                        "type": "array",
                        "description": "Indeed job IDs from the jk= URL param. Skips the listing crawl entirely. Fastest input mode.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyUrls": {
                        "title": "Indeed company pages",
                        "type": "array",
                        "description": "URLs to Indeed company pages (https://www.indeed.com/cmp/...). Pulls every job posted on that company page up to maxJobs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobs": {
                        "title": "Max jobs",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on jobs returned across all queries. Indeed paginates 15 jobs per page. Set 0 for everything Indeed exposes.",
                        "default": 25
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Filter by recency. Maps to Indeed's fromage param.",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "any",
                            "fulltime",
                            "parttime",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by employment type.",
                        "default": "any"
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "any",
                            "entry_level",
                            "mid_level",
                            "senior_level"
                        ],
                        "type": "string",
                        "description": "Filter by Indeed experience tag.",
                        "default": "any"
                    },
                    "remoteFilter": {
                        "title": "Remote / hybrid / on site",
                        "enum": [
                            "any",
                            "remote",
                            "hybrid",
                            "onsite"
                        ],
                        "type": "string",
                        "description": "Filter by work location type.",
                        "default": "any"
                    },
                    "minSalary": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Minimum salary in the local currency. Indeed often estimates salaries when the employer does not list one.",
                        "default": 0
                    },
                    "radius": {
                        "title": "Search radius (miles)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Distance from the location in miles. 0 means exact match. 25 is Indeed's default. Common values: 5, 10, 15, 25, 50, 100.",
                        "default": 25
                    },
                    "splitByCity": {
                        "title": "Split nationwide search into top cities",
                        "type": "boolean",
                        "description": "When you want lots of jobs from a country, Indeed caps each search at about 1000 results. Enable this to fan the search out across the country's top metro areas.",
                        "default": false
                    },
                    "scrapeCompanyDetails": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "Fetch each unique company's Indeed page and enrich rows with rating, total reviews, size band, industry, and founded year. Pushed as a separate dataset row per company.",
                        "default": false
                    },
                    "extractSkills": {
                        "title": "Extract skills",
                        "type": "boolean",
                        "description": "Detect mentioned skills in the job description (200+ tech and business skills, multi language).",
                        "default": true
                    },
                    "parseSalary": {
                        "title": "Parse salary into structured fields",
                        "type": "boolean",
                        "description": "Convert salary text into min, max, period, currency, and a normalized annual estimate. Distinguishes employer listed from Indeed estimated.",
                        "default": true
                    },
                    "classifySeniority": {
                        "title": "Classify seniority tier",
                        "type": "boolean",
                        "description": "Tag each job as intern, entry, mid, senior, lead, principal, staff, manager, director, vp, or c level based on title.",
                        "default": true
                    },
                    "detectEasyApply": {
                        "title": "Detect Easy Apply",
                        "type": "boolean",
                        "description": "Flag jobs that use Indeed's one click Easy Apply (vs employer redirect).",
                        "default": true
                    },
                    "detectRemoteHybrid": {
                        "title": "Detect remote and hybrid",
                        "type": "boolean",
                        "description": "Parse the location field and description for remote, hybrid, or on site work signals. Sets a workMode field on every row.",
                        "default": true
                    },
                    "followApplyRedirect": {
                        "title": "Follow apply redirect",
                        "type": "boolean",
                        "description": "Resolve the final Apply URL by following Indeed's redirect chain. Returns the employer's external ATS URL when present. Adds latency.",
                        "default": false
                    },
                    "dedupe": {
                        "title": "Deduplicate across runs",
                        "type": "boolean",
                        "description": "Skip job IDs already pushed in previous runs. Turn off to refresh stale rows.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of pages processed in parallel. Three to five is safe. Higher values trigger Cloudflare challenges.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential is required for Indeed at any meaningful volume. Datacenter is blocked within minutes.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
