# Indeed Jobs Scraper - Search, Filters & Browse Jobs (`lentic_clockss/indeed-jobs-scraper`) Actor

Scrape Indeed jobs from 60+ country sites. Extract titles, companies, salaries, locations, remote status, benefits, and descriptions via keyword search, SERP filters, or Browse Jobs. Browser + CapSolver + Apify RESIDENTIAL.

- **URL**: https://apify.com/lentic\_clockss/indeed-jobs-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

**Scrape Indeed job listings across 60+ country sites** — extract job titles, companies, salaries, locations, remote/hybrid status, benefits, ratings, and full descriptions. Search by keyword with SERP filters, or discover roles via Browse Jobs categories. This Actor is a practical **Indeed API alternative** for job market research, recruiting pipelines, and salary benchmarking.

Works with [Indeed](https://www.indeed.com/) country domains (for example `www.indeed.com`, `uk.indeed.com`, `ca.indeed.com`). Scraping runs on a hosted Cloud Run worker (Patchright headed Chrome + CapSolver + sticky Apify RESIDENTIAL); this Actor handles input, dataset output, and PPE.

### What does Indeed Jobs Scraper do?

Indeed Jobs Scraper lets you **extract structured job data from Indeed search results and job detail pages**. Give it a keyword and location (or a Browse Jobs category), pick one or more country sites, and start a run. The Actor returns clean dataset rows ready for CSV, Excel, JSON, or downstream APIs.

You can:

- Run **keyword search** with filters (job type, experience, remote/hybrid, education, date posted, radius, Indeed Apply)
- Discover jobs through **Browse Jobs** categories (`/browsejobs`)
- Scrape **up to 10 country sites in one run**
- Optionally open **job detail pages** for full descriptions
- Export results with host, country, salary text, benefits, and timestamps

### What job listing data can I extract from Indeed?

| Field | Description |
| --- | --- |
| Job title | Position name from the listing |
| Company | Employer name |
| Location | City / region / Remote text |
| Country + host | ISO-2 country and Indeed host used |
| Salary | Salary text when Indeed shows it |
| Job types | Full-time, part-time, contract, etc. |
| Remote / hybrid | Work setting when available |
| Benefits | Benefit chips when present |
| Company rating | Rating and review count when shown |
| Description | Full text when `scrapeDetails` is enabled |
| Posted time | Relative or timestamp when available |
| Job URL | Canonical Indeed job link |
| Browse category | Category label in browse mode |

### Why scrape Indeed job postings?

Indeed remains one of the largest public job boards worldwide. Scraping Indeed job listings helps you:

- Build custom job databases for recruiting or lead gen
- Benchmark salaries by role, location, and country
- Track hiring demand and skill trends over time
- Monitor competitors’ open roles
- Feed AI agents, CRM workflows, or enrichment pipelines
- Compare remote vs onsite demand across markets

### How to scrape Indeed jobs

1. Create a free [Apify](https://apify.com/) account.
2. Open [Indeed Jobs Scraper](https://apify.com/lentic_clockss/indeed-jobs-scraper).
3. Choose `search` or `browse` mode.
4. Enter a keyword and location (search), or a browse category.
5. Select a country site (or up to 10 via `countries`).
6. Optionally enable filters and `scrapeDetails`.
7. Click **Start** and download the Dataset as JSON, CSV, Excel, or JSONL.

#### Free Apify plan limits (set by this Actor's developer)

| Limit | Free Apify plan | Paid Apify plan |
| --- | --- | --- |
| Runs of this Actor | **10 runs total** | Unlimited |
| Results per run | **Up to 1,000** | Up to schema max (1,000) |

When the run cap is hit, the run finishes with a clear status message — not an Apify platform error.

> **Worker URL is config, not code:** the Actor reads `WORKER_BASE_URL` from Actor environment variables (plus optional per-run `workerBaseUrl`). If you migrate the worker to a new host, update `WORKER_BASE_URL` (and `WORKER_AUTH` if the API key changes) in Apify Console — no Actor code change required. Set `WORKER_PROVIDES_PROXY=1` when the worker supplies its own `PROXY_URL` instead of Apify RESIDENTIAL.

#### Example: search with filters (US)

```json
{
  "scrapeMode": "search",
  "keyword": "data analyst",
  "location": "Remote",
  "country": "us",
  "jobType": "fulltime",
  "experienceLevel": "entry_level",
  "remoteType": "remote",
  "datePosted": "7",
  "maxResults": 20,
  "scrapeDetails": true
}
````

#### Example: browse categories (US)

```json
{
  "scrapeMode": "browse",
  "country": "us",
  "browseCategory": "Healthcare",
  "maxCategories": 3,
  "maxResults": 15,
  "scrapeDetails": false
}
```

#### Example: multi-country batch

```json
{
  "keyword": "nurse",
  "countries": ["gb", "ie", "au"],
  "maxResults": 30,
  "scrapeDetails": false
}
```

### Input

| Field | Description |
| --- | --- |
| `scrapeMode` | `search` (keyword + filters) or `browse` (Browse Jobs categories) |
| `keyword` | Indeed `q` — job title, skills, or company (search mode) |
| `location` | Indeed `l` — city, region, zip, or Remote |
| `country` | Single Indeed country site (ISO-2) |
| `countries` | Optional batch of up to 10 ISO-2 country codes |
| `maxResults` | Maximum job records to return |
| `scrapeDetails` | Open detail pages for full descriptions |
| `jobType` / `experienceLevel` / `remoteType` / `education` | SERP filters |
| `datePosted` / `radius` / `sort` / `indeedApplyOnly` | More SERP controls |
| `browseCategory` / `maxCategories` | Browse mode controls |

See the **Input** tab for the full schema and defaults.

### Output sample

Each dataset item looks like this:

```json
{
  "source": "indeed",
  "job_id": "abc123",
  "title": "Data Analyst",
  "company": "Example Corp",
  "location_text": "Remote",
  "country": "us",
  "host": "www.indeed.com",
  "salary_text": "$80,000 - $110,000 a year",
  "job_types": ["Full-time"],
  "remote_type": "remote",
  "benefits": ["Health insurance", "Paid time off"],
  "company_rating": 3.9,
  "description": "We are looking for a Data Analyst...",
  "url": "https://www.indeed.com/viewjob?jk=abc123",
  "captured_at": "2026-07-20T05:00:00+00:00"
}
```

Diagnostics are stored in the key-value store as `RUN_SUMMARY` and `INPUT_ECHO`.

### How many Indeed jobs can this scraper return?

Throughput depends on keyword popularity, country site, filters, and whether detail pages are enabled. For large exports, raise `maxResults`, keep `scrapeDetails` off when you only need card-level fields, and split countries across runs if needed.

Results can vary day to day because Indeed SERPs are dynamic. A short test run is the best way to estimate volume for your query.

### Which Indeed country sites are supported?

All major Indeed country hosts from Indeed’s public country list are supported via ISO-2 codes, including:

`us`, `gb`, `ca`, `au`, `de`, `fr`, `jp`, `in`, `sg`, `ph`, `br`, `mx`, `ae`, `za`, `kr`, `my`, and 40+ more.

Examples: `us` → `www.indeed.com`, `gb` → `uk.indeed.com`, `my` → `malaysia.indeed.com`.

One run does **not** automatically sweep every country — pick `country` or up to 10 codes in `countries`.

### Indeed SERP filters (search mode)

| Input | Indeed parameter |
| --- | --- |
| `jobType` | `jt` (fulltime, parttime, contract, temporary, internship, …) |
| `experienceLevel` | `explvl` |
| `datePosted` | `fromage` (`1` / `3` / `7` / `14`) |
| `radius` | `radius` |
| `remoteType` | `sc` remote / hybrid attributes |
| `education` | `sc` education attributes |
| `encouragedToApply` | `sc` fairchance / no\_degree / military\_encouraged |
| `indeedApplyOnly` | `iafilter=1` |
| `scExtra` | Raw `sc` fragment for advanced chips |
| `sort` | `relevance` or `date` |

Dynamic skill chips depend on the query; use `scExtra` when you already know the token.

### Pricing

This Actor uses **Pay per event** pricing. You pay for:

| Event | Price |
| --- | --- |
| Actor start (`apify-actor-start`) | **$0.005** per start (scaled by memory GB) |
| Result (`apify-default-dataset-item`) | **$3.00 / 1,000** job items ($0.003 each) |

**Platform usage** (compute, residential proxy, etc.) is also billed to the user (`Pay per event + usage`). Pricing is versioned in `.actor/pricing.json` and can be re-applied with `scripts/sync_monetization.py`.

Example: one run that returns 1,000 jobs ≈ `$0.005` start + `$3.00` results, plus platform usage for that run.

### Privacy

Dataset `job_id` / `job_id_hash` fields store a truncated SHA-256 of the Indeed jobkey (plaintext keys are not emitted). Job URLs still include Indeed’s public `jk=` parameter so you can open listings.

### Live View / Standby

Standby Live View exposes operational endpoints only (`/`, `/health`, `/input-example`, `/openapi.json`). It does **not** scrape Indeed — start a normal Actor run for data collection.

### Can I use this as an Indeed API alternative?

Yes — for many job-search and market-research workflows. Indeed’s public developer APIs are mainly hiring-side. Publisher job-search APIs that used to expose searchable listings have been deprecated, so teams often use an Indeed scraper Actor for titles, companies, locations, salaries, and descriptions.

Use this Actor when you need:

- Searchable Indeed job listings as structured data
- Multi-country coverage without maintaining your own browser farm
- Exports into datasets, webhooks, or MCP / agent workflows

Always respect Indeed’s terms, robots rules, and applicable laws. Do not use scraped data to spam applicants or bypass apply flows. This Actor does not click Apply or Report.

### FAQ

#### Why did my free-plan run stop with a limit message?

Free Apify plan users can run this Actor up to **10 times**, with up to **1,000 results per run**. These caps are set by the **Actor developer, not Apify**. Upgrade to a paid Apify plan for unlimited runs (schema `maxResults` still applies).

#### How do I scrape Indeed jobs by location?

Set `location` (city, region, zip, or `Remote`) and optionally `radius`. Combine with `country` for the correct Indeed domain.

#### Can I scrape remote Indeed jobs only?

Yes. Set `remoteType` to `remote` (or `hybrid`) in search mode, and/or use `location: "Remote"`.

#### Does the Actor support Indeed Browse Jobs?

Yes. Set `scrapeMode` to `browse`, optionally filter with `browseCategory`, and control how many categories to follow with `maxCategories`.

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

No. The Actor scrapes public Indeed pages. CapSolver and Apify RESIDENTIAL proxy credentials are configured on the Actor side for reliability.

#### What happens if Indeed blocks a page?

Blocked or empty pages are recorded in `RUN_SUMMARY` warnings. Partial datasets may still be returned. CapSolver + residential proxy reduce block rates; extreme filters or high concurrency can still hit challenges.

#### Can I schedule recurring Indeed scrapes?

Yes. Use Apify Schedules or the API/client to run the Actor on a cron and append or replace datasets over time.

### Related Actors

- [LinkedIn Jobs Scraper](https://apify.com/lentic_clockss/linkedin-jobs-scraper)
- [RemoteOK Jobs Scraper](https://apify.com/lentic_clockss/remoteok-all-jobs-scraper)
- [Upwork Jobs Scraper](https://apify.com/lentic_clockss/upwork-jobs-scraper)

# Actor input Schema

## `scrapeMode` (type: `string`):

search = keyword SERP with filters. browse = discover /browsejobs categories then scrape category SERPs.

## `keyword` (type: `string`):

Job title, keywords, or company (Indeed q). Required for search mode.

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

City, state, zip, or Remote (Indeed l).

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

Indeed country domain (ISO-2). Invalid codes are rejected.

## `countries` (type: `array`):

Optional batch of up to 10 ISO-2 country codes. Invalid codes are skipped with a warning.

## `browseCategory` (type: `string`):

Optional category name filter for browse mode (e.g. Healthcare).

## `maxCategories` (type: `integer`):

Maximum Browse Jobs categories to follow.

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

Sort Indeed SERP by relevance or date.

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

Indeed fromage filter for recency.

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

Indeed jt filter (fulltime, parttime, ...).

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

Indeed explvl filter.

## `education` (type: `string`):

Best-effort on US/CA/GB/AU/IE SERP rails.

## `remoteType` (type: `string`):

Best-effort sc attr filters on US/CA/GB/AU/IE.

## `radius` (type: `string`):

Search radius in miles.

## `encouragedToApply` (type: `string`):

Indeed encouraged-to-apply sc tokens.

## `indeedApplyOnly` (type: `boolean`):

Only include Indeed Apply listings (iafilter=1).

## `scExtra` (type: `string`):

Optional raw Indeed sc fragment (attr(...)/explvl(...)/jt(...)). Validated.

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

Maximum job records to emit (1–1,000). Free Apify plan users: also limited to 10 total runs of this Actor (Actor developer policy).

## `maxPages` (type: `integer`):

Maximum SERP pages to fetch per query/category.

## `scrapeDetails` (type: `boolean`):

Open job detail pages for full descriptions.

## `detailConcurrency` (type: `integer`):

Parallel detail-page fetches (1-5).

## `proxyCountry` (type: `string`):

Optional ISO-2 for Apify RESIDENTIAL. Defaults to the site country. Ignored when Actor env WORKER\_PROVIDES\_PROXY=1 (worker supplies PROXY\_URL).

## `workerBaseUrl` (type: `string`):

Optional per-run override of the Cloud Run worker origin. Production runs should leave this empty and use Actor env WORKER\_BASE\_URL.

## Actor input object example

```json
{
  "scrapeMode": "search",
  "keyword": "data analyst",
  "location": "Remote",
  "country": "us",
  "countries": [],
  "browseCategory": "",
  "maxCategories": 20,
  "sort": "relevance",
  "datePosted": "",
  "jobType": "",
  "experienceLevel": "",
  "education": "",
  "remoteType": "",
  "radius": "",
  "encouragedToApply": "",
  "indeedApplyOnly": false,
  "scExtra": "",
  "maxResults": 50,
  "maxPages": 5,
  "scrapeDetails": true,
  "detailConcurrency": 3,
  "proxyCountry": ""
}
```

# Actor output Schema

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

Normalized job listings returned for the search.

## `runSummary` (type: `string`):

Status, counts, blockers, and timing for the run.

## `inputEcho` (type: `string`):

Normalized non-secret input showing the search scope.

## `errorSummary` (type: `string`):

Structured failure details when the run fails.

# 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 = {
    "keyword": "data analyst",
    "location": "Remote"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/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 = {
    "keyword": "data analyst",
    "location": "Remote",
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/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 '{
  "keyword": "data analyst",
  "location": "Remote"
}' |
apify call lentic_clockss/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper - Search, Filters & Browse Jobs",
        "description": "Scrape Indeed jobs from 60+ country sites. Extract titles, companies, salaries, locations, remote status, benefits, and descriptions via keyword search, SERP filters, or Browse Jobs. Browser + CapSolver + Apify RESIDENTIAL.",
        "version": "0.2",
        "x-build-id": "eIP5nDVQ5yF2bCHcp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-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/lentic_clockss~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-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/lentic_clockss~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-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": {
                    "scrapeMode": {
                        "title": "Scrape mode",
                        "enum": [
                            "search",
                            "browse"
                        ],
                        "type": "string",
                        "description": "search = keyword SERP with filters. browse = discover /browsejobs categories then scrape category SERPs.",
                        "default": "search"
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Job title, keywords, or company (Indeed q). Required for search mode.",
                        "default": "data analyst"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, zip, or Remote (Indeed l).",
                        "default": "Remote"
                    },
                    "country": {
                        "title": "Country site",
                        "enum": [
                            "ae",
                            "ar",
                            "at",
                            "au",
                            "be",
                            "bh",
                            "br",
                            "ca",
                            "ch",
                            "cl",
                            "cn",
                            "co",
                            "cr",
                            "cz",
                            "de",
                            "dk",
                            "ec",
                            "eg",
                            "es",
                            "fi",
                            "fr",
                            "gb",
                            "gr",
                            "hk",
                            "hu",
                            "id",
                            "ie",
                            "il",
                            "in",
                            "it",
                            "jp",
                            "kr",
                            "kw",
                            "lu",
                            "ma",
                            "mx",
                            "my",
                            "ng",
                            "nl",
                            "no",
                            "nz",
                            "om",
                            "pa",
                            "pe",
                            "ph",
                            "pk",
                            "pl",
                            "pt",
                            "qa",
                            "ro",
                            "sa",
                            "se",
                            "sg",
                            "th",
                            "tr",
                            "tw",
                            "ua",
                            "us",
                            "uy",
                            "ve",
                            "vn",
                            "za"
                        ],
                        "type": "string",
                        "description": "Indeed country domain (ISO-2). Invalid codes are rejected.",
                        "default": "us"
                    },
                    "countries": {
                        "title": "Countries (batch)",
                        "type": "array",
                        "description": "Optional batch of up to 10 ISO-2 country codes. Invalid codes are skipped with a warning.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "browseCategory": {
                        "title": "Browse category",
                        "type": "string",
                        "description": "Optional category name filter for browse mode (e.g. Healthcare).",
                        "default": ""
                    },
                    "maxCategories": {
                        "title": "Max browse categories",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum Browse Jobs categories to follow.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort Indeed SERP by relevance or date.",
                        "default": "relevance"
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Indeed fromage filter for recency.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "",
                            "fulltime",
                            "parttime",
                            "contract",
                            "temporary",
                            "internship",
                            "permanent",
                            "commission",
                            "new_grad",
                            "freelance",
                            "seasonal"
                        ],
                        "type": "string",
                        "description": "Indeed jt filter (fulltime, parttime, ...).",
                        "default": ""
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "",
                            "entry_level",
                            "mid_level",
                            "senior_level"
                        ],
                        "type": "string",
                        "description": "Indeed explvl filter.",
                        "default": ""
                    },
                    "education": {
                        "title": "Education",
                        "enum": [
                            "",
                            "high_school",
                            "associate",
                            "bachelor",
                            "master",
                            "doctoral"
                        ],
                        "type": "string",
                        "description": "Best-effort on US/CA/GB/AU/IE SERP rails.",
                        "default": ""
                    },
                    "remoteType": {
                        "title": "Remote / hybrid",
                        "enum": [
                            "",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Best-effort sc attr filters on US/CA/GB/AU/IE.",
                        "default": ""
                    },
                    "radius": {
                        "title": "Radius (miles)",
                        "enum": [
                            "",
                            "0",
                            "5",
                            "10",
                            "15",
                            "25",
                            "35",
                            "50",
                            "100"
                        ],
                        "type": "string",
                        "description": "Search radius in miles.",
                        "default": ""
                    },
                    "encouragedToApply": {
                        "title": "Encouraged to apply",
                        "enum": [
                            "",
                            "fairchance",
                            "no_degree",
                            "military_encouraged"
                        ],
                        "type": "string",
                        "description": "Indeed encouraged-to-apply sc tokens.",
                        "default": ""
                    },
                    "indeedApplyOnly": {
                        "title": "Indeed Apply only",
                        "type": "boolean",
                        "description": "Only include Indeed Apply listings (iafilter=1).",
                        "default": false
                    },
                    "scExtra": {
                        "title": "Advanced sc fragment",
                        "type": "string",
                        "description": "Optional raw Indeed sc fragment (attr(...)/explvl(...)/jt(...)). Validated.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max results (max 1,000; free users capped at 1,000/run)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum job records to emit (1–1,000). Free Apify plan users: also limited to 10 total runs of this Actor (Actor developer policy).",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max SERP pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum SERP pages to fetch per query/category.",
                        "default": 5
                    },
                    "scrapeDetails": {
                        "title": "Scrape job details",
                        "type": "boolean",
                        "description": "Open job detail pages for full descriptions.",
                        "default": true
                    },
                    "detailConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel detail-page fetches (1-5).",
                        "default": 3
                    },
                    "proxyCountry": {
                        "title": "Proxy country override",
                        "type": "string",
                        "description": "Optional ISO-2 for Apify RESIDENTIAL. Defaults to the site country. Ignored when Actor env WORKER_PROVIDES_PROXY=1 (worker supplies PROXY_URL).",
                        "default": ""
                    },
                    "workerBaseUrl": {
                        "title": "Worker base URL (Advanced)",
                        "type": "string",
                        "description": "Optional per-run override of the Cloud Run worker origin. Production runs should leave this empty and use Actor env WORKER_BASE_URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
