# Indeed Jobs Scraper - Most Comprehensive (`kaix/indeed-scraper`) Actor

🔥 ~$0.06/1K jobs 🔥 Extract accurate, structured job data from Indeed. Get ALL page results, not just the first page. 60+ fields per job with pre-parsed salary, verified company profiles, GPS coordinates, and hiring signals. 54 countries. Fast, low cost

- **URL**: https://apify.com/kaix/indeed-scraper.md
- **Developed by:** [Kai](https://apify.com/kaix) (community)
- **Categories:** Automation, Jobs
- **Stats:** 724 total users, 363 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.06 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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 Scraper - Most Comprehensive

The most complete Indeed scraper. 150+ fields per job, more than any other actor. Salary in dollars and cents, employer-provided attributes, CEO names, social links, click tracking URLs, hiring insights, GPS coordinates, company financials, and 8 structured attribute categories.

### Why use this scraper?

- Scrapes hundreds of jobs in seconds, not minutes
- Minimal compute usage per run, so platform fees stay tiny
- 150+ fields per job: pre-parsed salary, GPS coordinates, company dossier, normalized titles, employer tier, feed metadata, hiring insights, and more
- Exclusion-based skill extraction automatically classifies ~5000+ skills by filtering out known non-skill categories (benefits, certifications, education, etc.)
- Three search modes: Basic (fastest), Detailed (more data per job), or Rich (extra fields)
- Full pagination across every matching job
- 54 countries supported, in miles or kilometers
- Company search via `company:Name` returns all jobs from a specific employer
- Job lookup by key returns full data including expired status
- Clean nested output: `title{}`, `urls{}`, `classification{}`, `workArrangement{}`, `salary{}`, `apply{}`, `company{}`, `dates{}`, `signals{}`, `requirements{}`, `meta{}`

### Use cases

- Analyze hiring trends, salary ranges, and demand by role or location
- Benchmark compensation across companies, roles, and regions
- Monitor competitor hiring activity and open positions
- Build databases of hiring companies with industry, size, revenue, and CEO data
- Feed structured job data into your own job board or app
- Track job type distribution, benefits offered, and skills in demand

### How to use

#### Search by keyword + location

```json
{
  "keyword": "Data Analyst",
  "location": "New York, NY",
  "country": "US",
  "maxItems": 200,
  "sort": "date",
  "fromDays": "7"
}
````

#### Search by zipcode

```json
{
  "keyword": "software engineer",
  "location": "10001",
  "country": "US",
  "radius": "25",
  "radiusUnit": "miles",
  "maxItems": 50
}
```

#### Search by company

```json
{
  "keyword": "company:Google",
  "location": "San Francisco, CA",
  "maxItems": 100
}
```

#### Filter by job type and remote

```json
{
  "keyword": "Software Engineer",
  "location": "Austin, TX",
  "jobType": "fulltime",
  "remote": "remote",
  "radius": "50"
}
```

#### Search in kilometers (metric countries)

```json
{
  "keyword": "Developer",
  "location": "Berlin",
  "country": "DE",
  "radius": "50",
  "radiusUnit": "km"
}
```

#### Detailed search mode (hiring insights, benefits, requirements)

```json
{
  "keyword": "nurse",
  "location": "New York",
  "searchMode": "detailed",
  "maxItems": 100
}
```

Detailed mode fetches additional data per job: hiring insights, benefits, requirements with strictness levels, and more. Supports 1000+ results but takes longer.

#### Rich search mode (extra fields, fewer results)

```json
{
  "keyword": "nurse",
  "location": "New York",
  "searchMode": "rich",
  "maxItems": 100
}
```

Rich mode returns fewer results (~450 max) but includes extra fields: salary details, apply count, employer responsiveness, working hours, and company branding.

#### Look up specific jobs by key

Check if jobs are still active (returns expired status):

```json
{
  "jobKeys": ["5e5dafc2a80c214d", "550a48652b44bb83"],
  "country": "US"
}
```

### Input

**Search mode** (keyword + location):

| Parameter      | Type   | Default   | Description                                           |
| -------------- | ------ | --------- | ----------------------------------------------------- |
| **keyword**    | string | -         | Job title, skill, or `company:Name`                   |
| **location**   | string | -         | City, state, or ZIP code                              |
| **country**    | select | US        | 54 countries supported                                |
| **maxItems**   | number | 20        | Maximum number of job listings to scrape. Set to 0 for no limit. |
| **radius**     | select | 35        | Search distance: 0 to 100                             |
| **radiusUnit** | select | miles     | `miles` or `km`                                       |
| **sort**       | select | relevance | `relevance` or `date`                                 |
| **fromDays**   | select | any       | Posted within 1, 3, 7, or 14 days                     |
| **jobType**    | select | any       | Full-time, Part-time, Contract, Temporary, Internship |
| **remote**     | select | any       | Remote or Hybrid                                      |

> **Note:** Date filter cannot be combined with Job Type or Remote in the same search.

**Lookup mode** (job keys):

| Parameter   | Type     | Default | Description                                                             |
| ----------- | -------- | ------- | ----------------------------------------------------------------------- |
| **jobKeys** | string\[] | -       | Indeed job keys to look up. Returns full data including expired status. |
| **country** | select   | US      | Country for the job lookup                                              |

> When `jobKeys` is provided, search parameters are ignored.

**Advanced:**

| Parameter       | Type   | Default          | Description                                                                                               |
| --------------- | ------ | ---------------- | --------------------------------------------------------------------------------------------------------- |
| **searchMode**  | select | basic            | `basic`: fastest (1000+). `detailed`: more data per job (1000+, slower). `rich`: extra fields (~450 max). |
| **proxyConfig** | object | Apify datacenter | Optional. ISP/residential proxies reduce blocking.                                                        |

### Output

Each job listing contains 150+ structured fields:

#### Job details

```json
{
  "id": "5e5dafc2a80c214d",
  "refNum": "12345",
  "title": {
    "text": "Senior Data Analyst",
    "normalized": "data analyst"
  },
  "urls": {
    "indeed": "https://www.indeed.com/viewjob?jk=5e5dafc2a80c214d",
    "external": "https://careers.example.com/job/12345",
    "apply": "https://www.indeed.com/applystart?jk=...",
    "clickTracking": "http://www.indeed.com/rc/clk?jk=..."
  }
}
```

#### Description

`description{text, html}` `snippet`

#### Classification & Work arrangement

`classification{jobType, occupations, primaryOccupation, skills, languages, attributes{all, employerProvided}, employerProvidedOccupations}` `workArrangement{isRemote, locationType, remoteWorkType, remoteAttributes, shift, schedule, workSchedule, workingHours, travel}`

Skills are extracted using an exclusion-based approach: all attributes that don't belong to a known non-skill category (benefits, certifications, education, job type, shift, schedule, remote, language, work setting, physical requirements, compensation extras, eligibility, hiring meta, age requirements, experience duration, travel) are classified as skills. This captures ~5000+ unique skills automatically.

#### Salary & Benefits

```json
{
  "salary": {
    "text": "$120,000 - $180,000 a year",
    "min": 120000,
    "max": 180000,
    "minCents": "12000000",
    "maxCents": "18000000",
    "currency": "USD",
    "period": "yearly",
    "source": "EXTRACTION",
    "estimated": false,
    "detailed": null,
    "extracted": { "min": 120000, "max": 180000, "type": "YEARLY" },
    "snippet": { "currency": "USD", "source": "EXTRACTION", "text": "$120,000 - $180,000 a year" },
    "extras": ["Hourly pay", "Salary packaging", "Performance bonus"]
  },
  "benefits": ["Health insurance", "401(k)", "Paid time off"],
  "socialInsurance": { "EY33Q": "Health insurance", "FQJ2X": "Dental insurance" }
}
```

#### Location (with GPS)

```json
{
  "location": {
    "formatted": "San Francisco, CA 94105",
    "formattedShort": "San Francisco, CA",
    "fullAddress": "123 Market St, San Francisco, CA 94105",
    "city": "San Francisco",
    "state": "CA",
    "stateName": "California",
    "admin2Code": "075",
    "admin2Name": "San Francisco County",
    "postalCode": "94105",
    "streetAddress": "123 Market St",
    "latitude": 37.7749,
    "longitude": -122.4194,
    "country": "US",
    "countryName": "United States"
  }
}
```

#### Company profile

```json
{
  "company": {
    "name": "Citi",
    "key": "a1b2c3d4e5f6",
    "tier": "ENTERPRISE",
    "industry": "FINANCIAL SERVICES",
    "size": "10,000+",
    "revenue": "more than $10B (USD)",
    "briefDescription": "Citi is more than a global financial services company...",
    "fullDescription": "Citigroup Inc. is an American...",
    "brandColor": "#003B70",
    "customContents": ["Our Mission", "Life at Citi"],
    "urls": {
      "website": "http://www.citigroup.com",
      "indeed": "https://www.indeed.com/cmp/Citi"
    },
    "logos": {
      "square": "https://d2q79iu7y748jz.cloudfront.net/s/_squarelogo/256x256/...",
      "rectangular": null,
      "header": "https://d2q79iu7y748jz.cloudfront.net/s/_headerimage/..."
    },
    "ratings": {
      "overall": 3.9,
      "count": 15234,
      "reviewCount": 12500
    },
    "ceo": { "name": "Jane Fraser", "photoUrl": "..." },
    "socialLinks": { "facebook": "https://facebook.com/citi", "twitter": "https://twitter.com/citi", "instagram": null },
    "responsiveness": {
      "averageResponseTimeDays": 3,
      "responseRate": 0.85,
      "isActivelyReviewed": true,
      "lastActivityTimeInDays": 1
    },
    "parentEmployer": null,
    "phone": null,
    "featuredEmployer": false,
    "brandingReasons": ["PAID_BRANDING"]
  }
}
```

#### Dates

`dates{posted, onIndeed, validThrough, age, postedToday}`

#### Signals

`signals{isExpired, isSponsored, isBrandedJob, isUrgentHire, isHighVolumeHiring, isRepost, isLatestPost, isPlacement, isNew, employerResponsive, applyCount, numHires, matchScores, hiringTags, hiringInsights}`

#### Apply

```json
{
  "apply": {
    "url": "https://www.indeed.com/applystart?jk=...",
    "isEasyApply": true,
    "indeedApplyKey": "...",
    "scopes": ["DESKTOP", "MOBILE"],
    "resumeType": null,
    "organicApplyStarts": 42
  }
}
```

#### Hiring insights

```json
{
  "signals": {
    "hiringInsights": {
      "numOfCandidates": 20,
      "employerLastReviewed": "3",
      "recurringHireText": "This employer typically hires for this role",
      "isHiringEvent": false
    }
  }
}
```

#### Requirements

```json
{
  "requirements": {
    "certifications": ["CPA", "CFA"],
    "qualifications": ["Current TB test", "Reliable transportation"],
    "experienceLevel": "Senior level",
    "educationLevel": "Bachelor's degree",
    "attributes": [{ "key": "JB2WC", "label": "JavaScript", "provenance": "EXTRACTED", "requirementStrength": "PREFERRED" }],
    "physicalRequirements": ["Ability to lift 50 pounds", "Ability to stand for extended periods"],
    "eligibility": ["Background check", "US work authorization"],
    "ageRequirement": ["21 years or older"],
    "experienceDuration": ["4 years"]
  },
  "requiredDocuments": null
}
```

#### Meta

```json
{
  "meta": {
    "source": "Employer Direct",
    "feed": {
      "isDradis": false,
      "sourceType": "EMPLOYER"
    },
    "language": "en",
    "locale": "en_US",
    "scrapedAt": "2026-03-31T12:00:00.000Z",
    "search": { "keyword": "Data Analyst", "location": "New York, NY" },
    "scrapingInfo": { "page": 1, "index": 0 },
    "workSetting": ["Office", "Hospital"]
  }
}
```

### Performance

- Hundreds of results in seconds
- Minimal Apify compute usage per run
- Pay-per-result pricing, so no wasted credits on failed runs or empty pages

### Search modes explained

|                                  | Basic (default)          | Detailed                   | Rich                 |
| -------------------------------- | ------------------------ | -------------------------- | -------------------- |
| **Results**                      | 1000+                    | 1000+                      | ~450 max             |
| **Speed**                        | Fastest                  | Slower                     | Moderate             |
| **Hiring insights**              | No                       | Yes                        | No                   |
| **Benefits & requirements**      | Pre-classified           | Detailed (with strictness) | Pre-classified       |
| **Sponsored detection**          | No                       | No                         | Yes                  |
| **Working hours**                | No                       | No                         | Yes                  |
| **Salary source**                | Yes                      | Yes                        | Yes                  |
| **Company branding**             | No                       | No                         | Yes                  |
| **Employer-provided attributes** | Yes                      | Yes                        | Yes                  |
| **Click tracking URL**           | Yes                      | Yes                        | Yes                  |
| **Employer responsiveness**      | Yes                      | Yes                        | Yes                  |
| **Apply count**                  | No                       | No                         | Yes                  |
| **Best for**                     | Maximum speed & coverage | In-depth job analysis      | Competitive analysis |

### Limitations

- Date filter cannot be combined with Job Type or Remote filter in the same search.
- Company `ratings.count` is the number of star ratings; `ratings.reviewCount` is the number of written reviews. They often differ.
- Rich mode returns ~450 results max (Indeed's search limit).
- `isSponsored`, `applyCount`, `employerResponsive` signals are only available in Rich mode.
- Hiring insights, detailed benefits, and requirements with strictness are only available in Detailed mode.

# Actor input Schema

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

What job are you looking for? Enter a job title, skill, or company name.

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

Where? Enter a city, state, or ZIP code.

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

Which Indeed country site to search. Supports 54 countries.

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

Maximum number of job listings to scrape. Set to 0 for no limit (all results).

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

How far from the location to search.

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

Unit for search radius.

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

How to order the results.

## `fromDays` (type: `string`):

Only return recently posted jobs. Note: cannot be combined with Job Type or Remote filters.

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

Filter by employment type.

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

Filter for remote or hybrid positions.

## `jobKeys` (type: `array`):

Look up specific jobs by their Indeed job key (the ID from the job URL, e.g. "5e5dafc2a80c214d"). When provided, keyword/location search is skipped. Useful for checking if jobs are still active (expired field).

## `searchMode` (type: `string`):

Basic: fastest, up to 1000+ results with essential job data. Detailed: up to 1000+ results with additional hiring insights, benefits, and requirements per job (slower). Rich: up to ~450 results with extra fields like salary details, apply count, and hiring responsiveness.

## `proxyConfig` (type: `object`):

Proxy configuration. ISP/residential proxies reduce the chance of being blocked.

## Actor input object example

```json
{
  "keyword": "Software Engineer",
  "location": "San Francisco, CA",
  "country": "US",
  "maxItems": 20,
  "radius": "35",
  "radiusUnit": "miles",
  "sort": "relevance",
  "fromDays": "",
  "jobType": "",
  "remote": "",
  "jobKeys": [],
  "searchMode": "basic",
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# 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": "Software Engineer",
    "location": "San Francisco, CA"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaix/indeed-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": "Software Engineer",
    "location": "San Francisco, CA",
}

# Run the Actor and wait for it to finish
run = client.actor("kaix/indeed-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": "Software Engineer",
  "location": "San Francisco, CA"
}' |
apify call kaix/indeed-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper - Most Comprehensive",
        "description": "🔥 ~$0.06/1K jobs 🔥 Extract accurate, structured job data from Indeed. Get ALL page results, not just the first page. 60+ fields per job with pre-parsed salary, verified company profiles, GPS coordinates, and hiring signals. 54 countries. Fast, low cost",
        "version": "0.2",
        "x-build-id": "aZGEUy1jCH7Dmn0Sx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kaix~indeed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kaix-indeed-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/kaix~indeed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kaix-indeed-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/kaix~indeed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kaix-indeed-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": {
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "What job are you looking for? Enter a job title, skill, or company name."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where? Enter a city, state, or ZIP code."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "UK",
                            "CA",
                            "AU",
                            "IN",
                            "DE",
                            "FR",
                            "JP",
                            "BR",
                            "MX",
                            "IT",
                            "ES",
                            "NL",
                            "BE",
                            "CH",
                            "AT",
                            "SG",
                            "HK",
                            "IE",
                            "NZ",
                            "AR",
                            "BH",
                            "CL",
                            "CN",
                            "CO",
                            "CZ",
                            "DK",
                            "FI",
                            "GR",
                            "HU",
                            "ID",
                            "IL",
                            "KW",
                            "LU",
                            "MY",
                            "MA",
                            "NO",
                            "OM",
                            "PE",
                            "PH",
                            "PL",
                            "PT",
                            "QA",
                            "RO",
                            "SA",
                            "ZA",
                            "KR",
                            "SE",
                            "TW",
                            "TR",
                            "UA",
                            "AE",
                            "VE",
                            "VN"
                        ],
                        "type": "string",
                        "description": "Which Indeed country site to search. Supports 54 countries.",
                        "default": "US"
                    },
                    "maxItems": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape. Set to 0 for no limit (all results).",
                        "default": 20
                    },
                    "radius": {
                        "title": "Search Radius",
                        "enum": [
                            "0",
                            "5",
                            "10",
                            "15",
                            "25",
                            "35",
                            "50",
                            "100"
                        ],
                        "type": "string",
                        "description": "How far from the location to search.",
                        "default": "35"
                    },
                    "radiusUnit": {
                        "title": "Radius Unit",
                        "enum": [
                            "miles",
                            "km"
                        ],
                        "type": "string",
                        "description": "Unit for search radius.",
                        "default": "miles"
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "How to order the results.",
                        "default": "relevance"
                    },
                    "fromDays": {
                        "title": "Posted Within",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Only return recently posted jobs. Note: cannot be combined with Job Type or Remote filters.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "",
                            "fulltime",
                            "parttime",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by employment type.",
                        "default": ""
                    },
                    "remote": {
                        "title": "Remote / On-site",
                        "enum": [
                            "",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Filter for remote or hybrid positions.",
                        "default": ""
                    },
                    "jobKeys": {
                        "title": "Job Keys (lookup mode)",
                        "type": "array",
                        "description": "Look up specific jobs by their Indeed job key (the ID from the job URL, e.g. \"5e5dafc2a80c214d\"). When provided, keyword/location search is skipped. Useful for checking if jobs are still active (expired field).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchMode": {
                        "title": "Search Mode",
                        "enum": [
                            "basic",
                            "detailed",
                            "rich"
                        ],
                        "type": "string",
                        "description": "Basic: fastest, up to 1000+ results with essential job data. Detailed: up to 1000+ results with additional hiring insights, benefits, and requirements per job (slower). Rich: up to ~450 results with extra fields like salary details, apply count, and hiring responsiveness.",
                        "default": "basic"
                    },
                    "proxyConfig": {
                        "title": "Proxy Config",
                        "type": "object",
                        "description": "Proxy configuration. ISP/residential proxies reduce the chance of being blocked.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
