# Indeed Jobs Intelligence Scraper (`trakk/indeed-jobs-intelligence-scraper`) Actor

HTTP-only Indeed scraper for clean job data, external apply URLs, salary normalization, skills extraction, company enrichment, delta monitoring, and run quality reports.

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

## Pricing

from $2.00 / 1,000 job results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

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

Scrape Indeed job search results and job detail pages with an HTTP-only Apify Actor. The actor collects job postings, enriches them with structured detail data, normalizes salaries, extracts skills, resolves apply links, and can compare runs to detect new, updated, expired, or reposted jobs.

This actor is built for recruiting teams, job boards, labor market analytics, lead generation, salary benchmarking, and anyone who needs clean Indeed job data without running a browser-based scraper.

### What You Get

- Search Indeed by keyword, location, country, radius, date posted, job type, remote preference, and sort order.
- Start from ready-made Indeed search URLs, job URLs, or direct job IDs.
- Fetch full job details, including description, company, salary, benefits, employment type, dates, and source URLs.
- Enrich company profiles from Indeed company pages, including rating, company size, revenue, industry, CEO, links, header image, and company description when available.
- Normalize salary strings into min/max, currency, unit, and annualized values.
- Extract skills from job descriptions and attributes using rule-based skill dictionaries.
- Resolve apply links from Indeed buttons, redirect URLs, and job payloads, then detect common ATS providers such as Workday, Greenhouse, Lever, SmartRecruiters, Taleo, and Indeed Apply.
- Add structured location, requirements, emails, occupation tags, hiring-demand flags, remote flags, and compatibility fields for analytics.
- Deduplicate jobs by job key, URL, title, company, and location.
- Track changes between runs with delta monitoring.
- Produce company-level hiring intelligence and run quality reports.

### Output

The default dataset contains one item per job. Job items use a stable output shape: optional strings are emitted as `null`, optional arrays as `[]`, and optional objects as `{}`. This prevents Apify tables from showing missing columns as `undefined` when Indeed does not expose a field for a specific job.

`null` does not automatically mean a parsing error. It usually means the job or company page did not expose that field. For example, many jobs do not publish salary, some government jobs do not expose an Indeed company logo, and many job descriptions do not contain emails. The actor avoids inventing values: review counts, ratings, and job types such as `Full-time` are not treated as salary.

Depending on the data available on Indeed, items can include:

```json
{
  "jobKey": "f52b1b3f85fbccca",
  "title": "Senior Python Developer",
  "companyName": "Example Company",
  "location": "New York, NY, US",
  "salaryText": "USD 115000 - USD 180000 per year",
  "salaryMin": 115000,
  "salaryMax": 180000,
  "salaryCurrency": "USD",
  "salaryUnit": "year",
  "salaryAnnualMin": 115000,
  "salaryAnnualMax": 180000,
  "descriptionText": "Full job description...",
  "benefits": ["Health insurance", "Paid time off"],
  "extractedSkills": {
    "programmingLanguages": ["python", "sql"],
    "cloud": ["aws"],
    "all": ["aws", "python", "sql"]
  },
  "locationData": {
    "city": "New York",
    "countryCode": "US",
    "formattedAddressLong": "New York, NY, US"
  },
  "occupation": ["Software Developers", "Computer & Mathematical Occupations"],
  "hiringDemand": {
    "isHighVolumeHiring": false,
    "isUrgentHire": false
  },
  "companyNumEmployees": "10,000+",
  "companyRevenue": "more than $10B (USD)",
  "rating": { "rating": 4.1, "count": 1234 },
  "requirements": ["5+ years of Python experience"],
  "emails": [],
  "applyUrl": "https://jobs.example.com/job/senior-python-developer/123?utm_source=Indeed",
  "externalApplyUrl": "https://jobs.example.com/job/senior-python-developer/123?utm_source=Indeed",
  "finalApplyUrl": "https://jobs.example.com/job/senior-python-developer/123?utm_source=Indeed",
  "atsProvider": "Company Site",
  "applyUrlStatus": "external",
  "detailFetchError": null,
  "jobUrl": "https://www.indeed.com/viewjob?jk=...",
  "canonicalUrl": "https://www.indeed.com/viewjob?jk=...",
  "sourceUrl": "https://www.indeed.com/jobs?q=python+developer&l=New+York"
}
````

If a search or detail page is blocked after all retries, the actor follows the same defensive pattern as a production scraper: it keeps the run alive and writes a diagnostic error item to the default dataset instead of silently returning an empty dataset.

```json
{
  "type": "error",
  "errorType": "searchPageError",
  "sourceUrl": "https://www.indeed.com/jobs?q=python+developer&l=New+York",
  "searchQuery": "python developer",
  "searchLocation": "New York, NY",
  "page": 1,
  "error": "Blocked by target site, status=403",
  "detectedAt": "2026-05-19T09:57:51.000000+00:00"
}
```

The actor also writes additional run-scoped datasets:

- `companies`: company-level hiring summary with open job count, top roles, locations, remote share, average annual salary, and top skills.
- `changes`: delta monitoring output with `new`, `updated`, `expired`, and `reposted` jobs.
- `summary`: run quality report with scraped count, failed pages, duplicate count, missing salary/apply URL rates, retry stats, and runtime.

### Input

Use `SEARCH` mode to scrape jobs by query and location:

```json
{
  "mode": "SEARCH",
  "country": "us",
  "queries": ["python developer", "data analyst"],
  "locations": ["New York, NY", "Remote"],
  "maxResults": 100,
  "postedWithinDays": "7",
  "sort": "date",
  "enrichmentMode": "full",
  "enrichCompanyProfiles": true
}
```

Use `DETAIL` mode for known job URLs or job IDs:

```json
{
  "mode": "DETAIL",
  "country": "us",
  "jobIds": ["f52b1b3f85fbccca"],
  "startUrls": [
    { "url": "https://www.indeed.com/viewjob?jk=f52b1b3f85fbccca" }
  ],
  "enrichmentMode": "full",
  "enrichCompanyProfiles": true
}
```

### Main Settings

- `country`: Indeed country/domain, such as `us`, `gb`, `ca`, `au`, `de`, `fr`, `in`, and others.
- `queries`: keywords or job titles.
- `locations`: locations combined with each query.
- `startUrls`: Indeed search URLs or job detail URLs.
- `jobIds`: Indeed job keys to fetch directly.
- `maxResults`: maximum jobs to output.
- `maxPagesPerSearch`: pagination safety limit per search.
- `postedWithinDays`: date filter, for example `1`, `3`, `7`, `14`, or `30`.
- `jobType`: full-time, part-time, contract, temporary, internship, or commission.
- `remote`: remote, hybrid, or on-site preference.
- `enrichmentMode`: `fast` for search cards only or `full` for job detail enrichment.
- `dedupe`: skip duplicate jobs.
- `normalizeSalary`: add structured salary fields.
- `extractSkills`: add rule-based skill extraction.
- `resolveApplyUrls`: follow apply redirects when available.
- `enrichCompanyProfiles`: fetch one Indeed company page per unique company URL and merge company profile fields.
- `enableDeltaMonitoring`: compare current jobs with the previous run.
- `proxyConfiguration`: Apify proxy settings. Residential proxies are recommended.

### Proxy Recommendation

Indeed can return security checks to datacenter or low-trust IPs. For reliable runs, use Apify Residential proxies and match the proxy country to the Indeed domain:

```json
{
  "useApifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"],
  "apifyProxyCountry": "US"
}
```

### Technical Notes

This actor is HTTP-only. It does not run Playwright, Puppeteer, Selenium, or a headless browser during production scraping. Browser automation is used only for research and debugging outside the actor.

The HTTP client uses Chrome-like TLS/HTTP2 impersonation via `curl_cffi`, short request timeouts, retry budgets for network errors and blocks, and fresh sessions for retries.

### Limitations

- Available fields depend on what Indeed returns for each job, country, and page type.
- Some apply links stay inside Indeed Apply and may not expose an external ATS URL.
- Salary normalization is best-effort and depends on the salary text or structured salary data available on the page.
- Delta monitoring compares jobs seen by this actor across runs. If a run collects no jobs, the previous state is not overwritten.

### Local Development

Run the local parser smoke test:

```bash
python scripts/smoke_test.py
```

Deploy with Apify CLI:

```bash
deploy.bat
```

# Actor input Schema

## `mode` (type: `string`):

AUTO detects mode from provided input. SEARCH starts from query/location. DETAIL starts from job URLs or job IDs.

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

Indeed country/domain to use for generated search and detail URLs.

## `queries` (type: `array`):

Job titles or keywords to search for.

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

Locations to combine with every query. Use Remote for remote searches.

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

Indeed search URLs or job detail URLs. URL mode keeps the filters from the URL.

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

Indeed job keys to enrich directly.

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

Maximum number of jobs to output.

## `maxPagesPerSearch` (type: `integer`):

Safety limit for pagination per query/location or start URL.

## `postedWithinDays` (type: `string`):

Indeed fromage filter.

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

Indeed jt filter.

## `remote` (type: `string`):

Remote preference. Best-effort because Indeed varies filters by country.

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

Search radius in miles for Indeed domains that support it.

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

Sort order for generated search URLs.

## `enrichmentMode` (type: `string`):

fast outputs search cards only. full fetches every job detail page.

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

Skip duplicate job keys/canonical URLs.

## `normalizeSalary` (type: `boolean`):

Parse salary text into min/max/unit/currency and annualized fields.

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

Extract skills from job description and attributes using rule-based dictionaries.

## `resolveApplyUrls` (type: `boolean`):

Follow external apply redirects when an apply URL is available.

## `enrichCompanyProfiles` (type: `boolean`):

Fetch Indeed company pages once per company to add rating, company size, revenue, industry, description, links, CEO, header image, and addresses when available.

## `enableDeltaMonitoring` (type: `boolean`):

Compare the current run with the previous run stored in the default key-value store.

## `rawOutput` (type: `boolean`):

Include selected raw parser/debug fields. This can increase dataset size.

## `candidateProfile` (type: `object`):

Optional future/premium matching input. Basic skill matching is supported when skills are provided.

## `maxConcurrency` (type: `integer`):

Maximum parallel HTTP requests.

## `maxRetries` (type: `integer`):

Main retry budget for HTTP 429/5xx/parse errors. Proxy and block retries have separate budgets.

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

Residential proxies are recommended. Use country matching the Indeed domain.

## Actor input object example

```json
{
  "mode": "SEARCH",
  "country": "us",
  "queries": [
    "python developer"
  ],
  "locations": [
    "New York, NY"
  ],
  "jobIds": [],
  "maxResults": 20,
  "maxPagesPerSearch": 1,
  "postedWithinDays": "7",
  "jobType": "",
  "remote": "",
  "radius": 25,
  "sort": "date",
  "enrichmentMode": "full",
  "dedupe": true,
  "normalizeSalary": true,
  "extractSkills": true,
  "resolveApplyUrls": true,
  "enrichCompanyProfiles": true,
  "enableDeltaMonitoring": true,
  "rawOutput": false,
  "candidateProfile": {
    "skills": [
      "python",
      "sql",
      "aws"
    ],
    "targetSalaryAnnual": 120000
  },
  "maxConcurrency": 4,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "mode": "SEARCH",
    "country": "us",
    "queries": [
        "python developer"
    ],
    "locations": [
        "New York, NY"
    ],
    "jobIds": [],
    "maxResults": 20,
    "maxPagesPerSearch": 1,
    "postedWithinDays": "7",
    "jobType": "",
    "remote": "",
    "radius": 25,
    "sort": "date",
    "enrichmentMode": "full",
    "dedupe": true,
    "normalizeSalary": true,
    "extractSkills": true,
    "resolveApplyUrls": true,
    "enrichCompanyProfiles": true,
    "enableDeltaMonitoring": false,
    "rawOutput": false,
    "candidateProfile": {
        "skills": [],
        "targetSalaryAnnual": null
    },
    "maxConcurrency": 4,
    "maxRetries": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/indeed-jobs-intelligence-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 = {
    "mode": "SEARCH",
    "country": "us",
    "queries": ["python developer"],
    "locations": ["New York, NY"],
    "jobIds": [],
    "maxResults": 20,
    "maxPagesPerSearch": 1,
    "postedWithinDays": "7",
    "jobType": "",
    "remote": "",
    "radius": 25,
    "sort": "date",
    "enrichmentMode": "full",
    "dedupe": True,
    "normalizeSalary": True,
    "extractSkills": True,
    "resolveApplyUrls": True,
    "enrichCompanyProfiles": True,
    "enableDeltaMonitoring": False,
    "rawOutput": False,
    "candidateProfile": {
        "skills": [],
        "targetSalaryAnnual": None,
    },
    "maxConcurrency": 4,
    "maxRetries": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("trakk/indeed-jobs-intelligence-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 '{
  "mode": "SEARCH",
  "country": "us",
  "queries": [
    "python developer"
  ],
  "locations": [
    "New York, NY"
  ],
  "jobIds": [],
  "maxResults": 20,
  "maxPagesPerSearch": 1,
  "postedWithinDays": "7",
  "jobType": "",
  "remote": "",
  "radius": 25,
  "sort": "date",
  "enrichmentMode": "full",
  "dedupe": true,
  "normalizeSalary": true,
  "extractSkills": true,
  "resolveApplyUrls": true,
  "enrichCompanyProfiles": true,
  "enableDeltaMonitoring": false,
  "rawOutput": false,
  "candidateProfile": {
    "skills": [],
    "targetSalaryAnnual": null
  },
  "maxConcurrency": 4,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call trakk/indeed-jobs-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Intelligence Scraper",
        "description": "HTTP-only Indeed scraper for clean job data, external apply URLs, salary normalization, skills extraction, company enrichment, delta monitoring, and run quality reports.",
        "version": "0.1",
        "x-build-id": "1eQ39pOk3KDPXWYKd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~indeed-jobs-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-indeed-jobs-intelligence-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/trakk~indeed-jobs-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trakk-indeed-jobs-intelligence-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/trakk~indeed-jobs-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-indeed-jobs-intelligence-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "AUTO",
                            "SEARCH",
                            "DETAIL"
                        ],
                        "type": "string",
                        "description": "AUTO detects mode from provided input. SEARCH starts from query/location. DETAIL starts from job URLs or job IDs.",
                        "default": "AUTO"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "nl",
                            "es",
                            "it",
                            "br",
                            "in",
                            "sg",
                            "za"
                        ],
                        "type": "string",
                        "description": "Indeed country/domain to use for generated search and detail URLs.",
                        "default": "us"
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Job titles or keywords to search for.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "python developer"
                        ]
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Locations to combine with every query. Use Remote for remote searches.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "New York, NY"
                        ]
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Indeed search URLs or job detail URLs. URL mode keeps the filters from the URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "jobIds": {
                        "title": "Job IDs",
                        "type": "array",
                        "description": "Indeed job keys to enrich directly.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of jobs to output.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for pagination per query/location or start URL.",
                        "default": 10
                    },
                    "postedWithinDays": {
                        "title": "Posted within",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Indeed fromage filter.",
                        "default": "7"
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "",
                            "fulltime",
                            "parttime",
                            "contract",
                            "temporary",
                            "internship",
                            "commission"
                        ],
                        "type": "string",
                        "description": "Indeed jt filter.",
                        "default": ""
                    },
                    "remote": {
                        "title": "Remote filter",
                        "enum": [
                            "",
                            "remote",
                            "hybrid",
                            "on_site"
                        ],
                        "type": "string",
                        "description": "Remote preference. Best-effort because Indeed varies filters by country.",
                        "default": ""
                    },
                    "radius": {
                        "title": "Radius",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Search radius in miles for Indeed domains that support it.",
                        "default": 25
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort order for generated search URLs.",
                        "default": "relevance"
                    },
                    "enrichmentMode": {
                        "title": "Enrichment mode",
                        "enum": [
                            "fast",
                            "full"
                        ],
                        "type": "string",
                        "description": "fast outputs search cards only. full fetches every job detail page.",
                        "default": "full"
                    },
                    "dedupe": {
                        "title": "Deduplicate jobs",
                        "type": "boolean",
                        "description": "Skip duplicate job keys/canonical URLs.",
                        "default": true
                    },
                    "normalizeSalary": {
                        "title": "Normalize salary",
                        "type": "boolean",
                        "description": "Parse salary text into min/max/unit/currency and annualized fields.",
                        "default": true
                    },
                    "extractSkills": {
                        "title": "Extract skills",
                        "type": "boolean",
                        "description": "Extract skills from job description and attributes using rule-based dictionaries.",
                        "default": true
                    },
                    "resolveApplyUrls": {
                        "title": "Resolve apply URLs",
                        "type": "boolean",
                        "description": "Follow external apply redirects when an apply URL is available.",
                        "default": true
                    },
                    "enrichCompanyProfiles": {
                        "title": "Enrich company profiles",
                        "type": "boolean",
                        "description": "Fetch Indeed company pages once per company to add rating, company size, revenue, industry, description, links, CEO, header image, and addresses when available.",
                        "default": true
                    },
                    "enableDeltaMonitoring": {
                        "title": "Delta monitoring",
                        "type": "boolean",
                        "description": "Compare the current run with the previous run stored in the default key-value store.",
                        "default": true
                    },
                    "rawOutput": {
                        "title": "Raw output",
                        "type": "boolean",
                        "description": "Include selected raw parser/debug fields. This can increase dataset size.",
                        "default": false
                    },
                    "candidateProfile": {
                        "title": "Candidate profile",
                        "type": "object",
                        "description": "Optional future/premium matching input. Basic skill matching is supported when skills are provided.",
                        "default": {
                            "skills": [],
                            "targetSalaryAnnual": null
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum parallel HTTP requests.",
                        "default": 5
                    },
                    "maxRetries": {
                        "title": "Max retries",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Main retry budget for HTTP 429/5xx/parse errors. Proxy and block retries have separate budgets.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are recommended. Use country matching the Indeed domain.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
