# Indeed Jobs Scraper (`kmiloaguilar/indeed-jobs-scraper`) Actor

Extract public Indeed job listings into clean Apify datasets for recruiting intelligence, talent pipeline building, competitor monitoring, and hiring analytics.

- **URL**: https://apify.com/kmiloaguilar/indeed-jobs-scraper.md
- **Developed by:** [Camilo Aguilar](https://apify.com/kmiloaguilar) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 job listings

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 Scraper

Extract public Indeed job listings into clean Apify datasets for recruiting intelligence, talent pipeline building, labor-market research, competitor hiring monitoring, and job-board aggregation.

This actor searches Indeed by keyword, location, country site, posting age, radius, job type, remote filter, experience level, and sort order. It can also scrape direct Indeed search URLs or `/viewjob` URLs. Results are normalized into a stable schema with job identity, company details, location, salary, descriptions, apply links, and scraping diagnostics.

### Why Choose This Actor

- Pay per saved result: pricing is `$3.00 / 1,000 saved jobs`.
- Search-only or enriched output: disable detail pages for speed, or enable detail pages for full descriptions and richer company/apply data.
- Stable dataset schema: missing fields are returned as `null` or empty arrays instead of changing the output shape.
- Block-aware request flow: when regular HTTP receives a `403`, the actor retries with browser TLS impersonation.
- Deduplication included: duplicate jobs across pages and generated search segments are skipped by default.
- Buyer-visible diagnostics: each run writes `RUN_SUMMARY` with saved count, duplicate count, filtered count, stop reason, and field coverage.
- Migration-friendly inputs: common snake_case aliases are accepted for easier integration.
- Proxy flexible: supports Apify Proxy, custom `proxyUrl`, `DEFAULT_PROXY_URL`, and DataImpulse environment variables.

### Common Use Cases

- Talent acquisition: build candidate sourcing lists by role, location, and posting age.
- Competitor monitoring: track which companies are hiring, where, and for which roles.
- Compensation research: collect salary text and normalized salary bounds where Indeed exposes them.
- Labor-market analytics: compare job demand by geography, keyword, company, and date window.
- Job-board aggregation: feed normalized records into search, alerts, dashboards, or enrichment pipelines.
- Sales prospecting: find companies actively hiring for roles that indicate buying intent.

### Quick Start

Search for jobs by keyword and location:

```json
{
  "query": "data analyst",
  "location": "Toronto, ON",
  "country": "ca.indeed.com",
  "maxItems": 100,
  "scrapeDetailPages": true
}
````

Use search-only mode for lower cost and faster exports:

```json
{
  "query": "software engineer",
  "location": "San Francisco, CA",
  "country": "www.indeed.com",
  "maxItems": 500,
  "scrapeDetailPages": false,
  "maxConcurrency": 5
}
```

Scrape a precise Indeed URL:

```json
{
  "startUrls": [
    "https://www.indeed.com/jobs?q=product+manager&l=New+York&fromage=1"
  ],
  "maxItems": 250,
  "scrapeDetailPages": true
}
```

### Output

Each saved item represents one Indeed job listing. The schema stays consistent across search-only and detail-enriched runs.

```json
{
  "data_source": "Indeed",
  "job_key": "abc123",
  "job_url": "https://ca.indeed.com/viewjob?jk=abc123",
  "apply_url": "https://ca.indeed.com/applystart?jk=abc123",
  "title": "Data Analyst",
  "company_name": "Example Co",
  "company_url": "https://ca.indeed.com/cmp/example-co",
  "company_logo_url": null,
  "company_header_url": null,
  "company_rating": 4.2,
  "company_review_count": 128,
  "company_active_jobs_count": null,
  "company_industry": null,
  "company_size": null,
  "company_revenue": null,
  "company_headquarters": null,
  "company_ceo": null,
  "location": "Toronto, ON",
  "city": "Toronto",
  "country": "CA",
  "street_address": null,
  "postal_code": null,
  "latitude": 43.6532,
  "longitude": -79.3832,
  "salary": "$80,000 a year",
  "salary_min": 80000,
  "salary_max": null,
  "salary_currency": "CAD",
  "job_type": "Full-time",
  "posted_at": "2026-06-10",
  "relative_time": "3 days ago",
  "description_text": "Build hiring analytics dashboards.",
  "description_html": "<p>Build hiring analytics dashboards.</p>",
  "benefits": ["Dental insurance"],
  "attributes": ["Python", "SQL"],
  "requirements": [],
  "expired": false,
  "indeed_apply": true,
  "is_sponsored": false,
  "detail_status": "fetched",
  "detail_error": null,
  "scraping_page": 1,
  "scraping_index": 0,
  "input_query": "data analyst",
  "input_location": "Toronto, ON",
  "input_country": "ca.indeed.com"
}
```

### Data Fields

| Group | Fields |
|---|---|
| Job identity | `data_source`, `job_key`, `job_url`, `apply_url` |
| Job content | `title`, `description_text`, `description_html`, `job_type`, `posted_at`, `relative_time` |
| Company | `company_name`, `company_url`, `company_logo_url`, `company_header_url`, `company_rating`, `company_review_count`, `company_active_jobs_count`, `company_industry`, `company_size`, `company_revenue`, `company_headquarters`, `company_ceo` |
| Location | `location`, `city`, `country`, `street_address`, `postal_code`, `latitude`, `longitude` |
| Compensation | `salary`, `salary_min`, `salary_max`, `salary_currency`, `benefits` |
| Classification | `attributes`, `requirements`, `expired`, `indeed_apply`, `is_sponsored` |
| Diagnostics | `detail_status`, `detail_error`, `scraping_page`, `scraping_index`, `input_query`, `input_location`, `input_country` |

Indeed does not expose every field on every job, country site, or result page. Unavailable values are returned as `null` or `[]`.

### Detail Pages

Set `scrapeDetailPages` based on your workflow:

- `false`: faster, lower-cost search result extraction. Good for large candidate lists, job counts, and market snapshots.
- `true`: fetches each job detail page for full descriptions, richer apply links, and additional company fields where available.

Detail-enriched records include `detail_status`:

| Status | Meaning |
|---|---|
| `fetched` | Detail page was fetched and a readable description was found. |
| `fetched_no_description` | Detail page was fetched, but no description field was extractable. |
| `failed` | Detail fetch or parsing failed. `detail_error` contains a short diagnostic. |
| `no_url` | The record did not include a usable job URL. |
| `not_requested` | `scrapeDetailPages` was disabled. |

### Inputs

| Option | Type | Default | Description |
|---|---:|---:|---|
| `startUrls` | array | empty | Indeed search result URLs or direct `/viewjob` URLs. |
| `query` | string | `data analyst` | Job keywords used when `startUrls` is empty. |
| `location` | string | `New York, NY` | City, region, country, or postal code. |
| `country` | string | `www.indeed.com` | Indeed host or alias such as `us`, `ca`, `uk`, `www.indeed.com`, `ca.indeed.com`. |
| `maxItems` | integer | `100` | Maximum unique job records to save. |
| `startPage` | integer | `1` | First search results page, using 1-indexed page numbers. |
| `endPage` | integer | empty | Last search results page. Leave empty to continue until `maxItems` is reached. |
| `pageSize` | integer | `15` | Expected jobs per search page, used for pagination offsets and stopping logic. |
| `postedWithinDays` | integer | `7` | Indeed date filter. Common values are `1`, `3`, `7`, and `14`. |
| `radiusKm` | integer | `25` | Search radius around the location. |
| `jobType` | string | `any` | `any`, `full-time`, `part-time`, `contract`, `internship`, or `temporary`. |
| `remoteWorkType` | string | `any` | `any`, `remote`, `hybrid`, or `on-site`. `remote` maps to Indeed's remote-only URL filter. |
| `sort` | string | `relevance` | `relevance` or `date`. |
| `experienceLevel` | string | `any` | `any`, `entry-level`, `mid-level`, or `senior-level` where Indeed supports it. |
| `excludeEmployers` | array | empty | Employer names or substrings to exclude after extraction. |
| `excludeSalaryTypes` | array | empty | Salary cadence labels to exclude after extraction, such as `hourly`. |
| `dedupeJobs` | boolean | `true` | Skip duplicate jobs across pages and generated search segments. |
| `scrapeDetailPages` | boolean | `true` | Fetch each job page for description and richer apply/company data. |
| `maxConcurrency` | integer | `20` | Parallel request limit. Lower this if the target site starts rate limiting. |
| `requestDelayMillis` | integer | `0` | Optional delay after successful requests. |
| `requestRetries` | integer | `2` | Retry count for failed requests. |
| `retryDelayMillis` | integer | `1000` | Delay between retries. |
| `requestTimeoutSecs` | integer | `30` | HTTP timeout per request. |
| `proxyUrl` | string | empty | Optional custom proxy URL. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Apify Proxy settings. |

Country aliases include `us`, `usa`, `ca`, `canada`, `uk`, `gb`, `au`, `de`, `fr`, and `es`.

### Advanced Search Segments

Indeed may stop returning new jobs for one broad search even when more results appear to exist. For larger exports, split the run into smaller search segments and let the actor deduplicate across them.

```json
{
  "query": "data analyst",
  "queryVariants": ["business analyst", "analytics engineer", "reporting analyst"],
  "location": "Toronto, ON",
  "locationVariants": ["Mississauga, ON", "Markham, ON", "Vaughan, ON"],
  "country": "ca.indeed.com",
  "postedWithinDays": 14,
  "postedWithinDaysSegments": [7, 3, 1],
  "radiusKm": 25,
  "radiusKmSegments": [50],
  "maxSearchSegments": 20,
  "maxItems": 1000,
  "scrapeDetailPages": false
}
```

Segment inputs:

| Option | Description |
|---|---|
| `queryVariants` | Extra keyword searches. The main `query` is tried first. |
| `locationVariants` | Extra locations. The main `location` is tried first. |
| `postedWithinDaysSegments` | Extra date windows, such as `1`, `3`, `7`, `14`. |
| `radiusKmSegments` | Extra radius values. |
| `maxSearchSegments` | Maximum generated search URLs from query, location, date, and radius combinations. |

### Proxy And Blocking Behavior

The actor uses Apify Proxy by default through `proxyConfiguration`. You can also provide:

- `proxyUrl`: direct proxy URL in input.
- `DEFAULT_PROXY_URL`: full proxy URL as an environment variable or secret.
- `DATAIMPULSE_PROXY_URL` or `DATAIMPULSE_URL`: full DataImpulse proxy URL.
- `DATAIMPULSE_PROXY_HOST`, `DATAIMPULSE_PROXY_PORT`, `DATAIMPULSE_PROXY_USERNAME`, `DATAIMPULSE_PROXY_PASSWORD`: split proxy credentials.
- Short DataImpulse aliases: `DATAIMPULSE_HOST`, `DATAIMPULSE_PORT`, `DATAIMPULSE_USER`, `DATAIMPULSE_PASS`, and optional `DATAIMPULSE_SCHEME`.

When a request receives `403`, the actor retries with browser TLS impersonation. If Indeed changes its protections, runs may still return fewer jobs or stop early; check `RUN_SUMMARY.stop_reason`, `detail_status`, and `detail_error`.

### Billing And Max Charge Safety

This actor is billed per saved job listing:

- Price: `$0.003` per saved dataset item.
- Displayed price: `$3.00 / 1,000 saved jobs`.
- Empty pages, duplicate-only pages, blocked pages, failed detail requests, and diagnostics are not saved as paid job results.

The actor's `RUN_SUMMARY.billable_saved_jobs` equals the number of saved dataset records.

If a user sets a maximum run charge, configure `maxItems` so the actor cannot save more paid records than the user intended. A safe estimate is:

```text
maxItems = floor(maximum_run_charge / 0.003)
```

Examples:

| Maximum charge | Safe `maxItems` |
|---:|---:|
| `$3` | `1000` |
| `$15` | `5000` |
| `$30` | `10000` |

### Run Summary And Quality Checks

Every run writes a `RUN_SUMMARY` key-value store record with:

- requested max items
- pages attempted
- search URLs planned and attempted
- saved count
- duplicate count
- filtered count
- no-job pages
- stop reason
- field coverage by key field
- billable saved jobs

Stop reasons:

| Stop reason | Meaning |
|---|---|
| `max_items_reached` | The requested `maxItems` was saved. |
| `end_page_reached` | Pagination reached `endPage` or a short final page. |
| `detail_url_completed` | A direct `/viewjob` URL was processed. |
| `no_jobs_found` | A page produced no extractable jobs. |
| `no_new_unique_jobs` | A page only contained jobs already saved in the run. |
| `completed` | All start URLs were processed without another stop reason. |

Use `RUN_SUMMARY.field_coverage` to check whether descriptions, salaries, company fields, geodata, benefits, apply URLs, and detail statuses are being populated for a run.

### Compatibility Aliases

The actor accepts these snake\_case aliases for easier integration:

| Alias | Canonical input |
|---|---|
| `start_urls` | `startUrls` |
| `max_items` | `maxItems` |
| `posted_within_days` | `postedWithinDays` |
| `radius_km` | `radiusKm` |
| `scrape_detail_pages` | `scrapeDetailPages` |
| `max_concurrency` | `maxConcurrency` |
| `proxy_url` | `proxyUrl` |
| `request_retries` | `requestRetries` |
| `request_timeout_secs` | `requestTimeoutSecs` |
| `retry_delay_millis` | `retryDelayMillis` |
| `request_delay_millis` | `requestDelayMillis` |
| `start_page` | `startPage` |
| `end_page` | `endPage` |
| `query_variants` | `queryVariants` |
| `location_variants` | `locationVariants` |
| `posted_within_days_segments` | `postedWithinDaysSegments` |
| `radius_km_segments` | `radiusKmSegments` |
| `max_search_segments` | `maxSearchSegments` |
| `job_type` | `jobType` |
| `remote_work_type` | `remoteWorkType` |
| `experience_level` | `experienceLevel` |
| `exclude_employers` | `excludeEmployers` |
| `exclude_salary_types` | `excludeSalaryTypes` |
| `dedupe_jobs` | `dedupeJobs` |

When both spellings are provided, the camelCase input wins.

### Reliability Notes

This actor is designed to address common buyer concerns with Indeed scrapers:

- Blocked requests: retries with browser TLS impersonation after `403`.
- Missing descriptions: detail-page mode fetches full descriptions when available and marks failures per record.
- Duplicate records: deduplication is enabled by default across pages and segments.
- Unclear output shape: the dataset schema remains stable with nulls or empty arrays for unavailable fields.
- Overcharging risk: charge only for saved dataset items, not starts or failed pages.
- Large result limits: use search segments to fan out broad searches into smaller deduplicated runs.
- Troubleshooting: `RUN_SUMMARY`, `detail_status`, and `detail_error` show what happened.

### Support

Open an issue on this actor's Apify page for bugs, blocked runs, feature requests, missing fields, or country/filter requests. Include the run ID, input JSON, expected result count, and whether detail pages were enabled.

Maintained by Camilo Aguilar, Aguilar Hernandez Consultants Inc.

### Compliance

This actor is intended for extracting publicly available job listing information for legitimate research, analytics, and workflow automation. Users are responsible for ensuring their usage complies with Indeed terms, applicable law, privacy requirements, and downstream data-processing obligations.

This actor is not affiliated with, endorsed by, or sponsored by Indeed.

# Actor input Schema

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

Indeed search result URLs or /viewjob detail URLs to scrape.

## `query` (type: `string`):

Search keywords, used when startUrls is empty.

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

City, region, country, or postal code for Indeed search.

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

Indeed host to scrape.

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

Maximum unique job records to save.

## `startPage` (type: `integer`):

First Indeed search-results page to scrape, using 1-indexed page numbers.

## `endPage` (type: `integer`):

Last Indeed search-results page to scrape, inclusive. Leave empty to continue until maxItems is reached.

## `pageSize` (type: `integer`):

Expected jobs per Indeed search-results page, used for pagination offsets and stopping logic.

## `queryVariants` (type: `array`):

Optional extra keyword searches for segmented large-result runs. The main query is always tried first.

## `locationVariants` (type: `array`):

Optional extra locations for segmented large-result runs. The main location is always tried first.

## `postedWithinDaysSegments` (type: `array`):

Optional extra Indeed fromage values to fan out large searches, for example 1, 3, 7, and 14.

## `radiusKmSegments` (type: `array`):

Optional extra radius values to fan out large searches while deduplicating jobs across segments.

## `maxSearchSegments` (type: `integer`):

Maximum generated search URLs when query, location, date, or radius segments are provided.

## `postedWithinDays` (type: `integer`):

Indeed date filter. Common values are 1, 3, 7, and 14.

## `radiusKm` (type: `integer`):

Radius around location, converted to Indeed radius parameter.

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

Indeed job type filter.

## `remoteWorkType` (type: `string`):

Remote work filter. Remote maps to Indeed's remote-only URL filter; hybrid and on-site are accepted for compatibility but not forced unless Indeed exposes them in the result page.

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

Sort Indeed results by relevance or date.

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

Indeed experience-level filter where supported by the selected country site.

## `excludeEmployers` (type: `array`):

Employer names or substrings to exclude after extraction.

## `excludeSalaryTypes` (type: `array`):

Salary cadence labels to exclude after extraction, for example hourly jobs.

## `dedupeJobs` (type: `boolean`):

Skip duplicate jobs across pages and segmented searches.

## `scrapeDetailPages` (type: `boolean`):

Fetch each job page for description and richer apply/company data.

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

How many Indeed pages to fetch in parallel.

## `requestDelayMillis` (type: `integer`):

Optional delay after each successful request while holding a concurrency slot. Keep 0 for speed; raise it if Indeed starts rate limiting.

## `proxyUrl` (type: `string`):

Optional proxy URL. Leave empty to use DEFAULT\_PROXY\_URL when configured, or Apify Proxy through proxyConfiguration.

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

Optional Apify proxy configuration. Defaults to Apify Proxy when no proxyUrl or DEFAULT\_PROXY\_URL is set.

## `requestRetries` (type: `integer`):

Retry count for failed requests.

## `retryDelayMillis` (type: `integer`):

Delay between retry attempts after a failed request.

## `requestTimeoutSecs` (type: `integer`):

HTTP timeout per request.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.indeed.com/jobs?q=data+analyst&l=New+York%2C+NY&fromage=7"
    }
  ],
  "query": "data analyst",
  "location": "New York, NY",
  "country": "www.indeed.com",
  "maxItems": 100,
  "startPage": 1,
  "pageSize": 15,
  "maxSearchSegments": 20,
  "postedWithinDays": 7,
  "radiusKm": 25,
  "jobType": "any",
  "remoteWorkType": "any",
  "sort": "relevance",
  "experienceLevel": "any",
  "dedupeJobs": true,
  "scrapeDetailPages": true,
  "maxConcurrency": 20,
  "requestDelayMillis": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestRetries": 2,
  "retryDelayMillis": 1000,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

Scraped Indeed job records with job identity, company, location, salary, description, benefits, flags, and scraping metadata.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.indeed.com/jobs?q=data+analyst&l=New+York%2C+NY&fromage=7"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kmiloaguilar/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 = { "startUrls": [{ "url": "https://www.indeed.com/jobs?q=data+analyst&l=New+York%2C+NY&fromage=7" }] }

# Run the Actor and wait for it to finish
run = client.actor("kmiloaguilar/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 '{
  "startUrls": [
    {
      "url": "https://www.indeed.com/jobs?q=data+analyst&l=New+York%2C+NY&fromage=7"
    }
  ]
}' |
apify call kmiloaguilar/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper",
        "description": "Extract public Indeed job listings into clean Apify datasets for recruiting intelligence, talent pipeline building, competitor monitoring, and hiring analytics.",
        "version": "0.1",
        "x-build-id": "7xEgCbgmsyrUX6hoJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kmiloaguilar~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kmiloaguilar-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/kmiloaguilar~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kmiloaguilar-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/kmiloaguilar~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kmiloaguilar-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Indeed search result URLs or /viewjob detail URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Job keywords",
                        "type": "string",
                        "description": "Search keywords, used when startUrls is empty.",
                        "default": "data analyst"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, country, or postal code for Indeed search.",
                        "default": "New York, NY"
                    },
                    "country": {
                        "title": "Country site",
                        "enum": [
                            "us",
                            "ca",
                            "uk",
                            "gb",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "www.indeed.com",
                            "ca.indeed.com",
                            "uk.indeed.com",
                            "au.indeed.com",
                            "de.indeed.com",
                            "fr.indeed.com",
                            "es.indeed.com"
                        ],
                        "type": "string",
                        "description": "Indeed host to scrape.",
                        "default": "www.indeed.com"
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum unique job records to save.",
                        "default": 100
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "First Indeed search-results page to scrape, using 1-indexed page numbers.",
                        "default": 1
                    },
                    "endPage": {
                        "title": "End page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Last Indeed search-results page to scrape, inclusive. Leave empty to continue until maxItems is reached."
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Expected jobs per Indeed search-results page, used for pagination offsets and stopping logic.",
                        "default": 15
                    },
                    "queryVariants": {
                        "title": "Query variants",
                        "type": "array",
                        "description": "Optional extra keyword searches for segmented large-result runs. The main query is always tried first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationVariants": {
                        "title": "Location variants",
                        "type": "array",
                        "description": "Optional extra locations for segmented large-result runs. The main location is always tried first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postedWithinDaysSegments": {
                        "title": "Posted date segments",
                        "type": "array",
                        "description": "Optional extra Indeed fromage values to fan out large searches, for example 1, 3, 7, and 14.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "radiusKmSegments": {
                        "title": "Radius segments in km",
                        "type": "array",
                        "description": "Optional extra radius values to fan out large searches while deduplicating jobs across segments.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSearchSegments": {
                        "title": "Maximum search segments",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum generated search URLs when query, location, date, or radius segments are provided.",
                        "default": 20
                    },
                    "postedWithinDays": {
                        "title": "Posted within days",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Indeed date filter. Common values are 1, 3, 7, and 14.",
                        "default": 7
                    },
                    "radiusKm": {
                        "title": "Search radius in km",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Radius around location, converted to Indeed radius parameter.",
                        "default": 25
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "any",
                            "full-time",
                            "part-time",
                            "contract",
                            "internship",
                            "temporary"
                        ],
                        "type": "string",
                        "description": "Indeed job type filter.",
                        "default": "any"
                    },
                    "remoteWorkType": {
                        "title": "Remote work type",
                        "enum": [
                            "any",
                            "remote",
                            "hybrid",
                            "on-site"
                        ],
                        "type": "string",
                        "description": "Remote work filter. Remote maps to Indeed's remote-only URL filter; hybrid and on-site are accepted for compatibility but not forced unless Indeed exposes them in the result page.",
                        "default": "any"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort Indeed results by relevance or date.",
                        "default": "relevance"
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "any",
                            "entry-level",
                            "mid-level",
                            "senior-level"
                        ],
                        "type": "string",
                        "description": "Indeed experience-level filter where supported by the selected country site.",
                        "default": "any"
                    },
                    "excludeEmployers": {
                        "title": "Exclude employers",
                        "type": "array",
                        "description": "Employer names or substrings to exclude after extraction.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeSalaryTypes": {
                        "title": "Exclude salary types",
                        "type": "array",
                        "description": "Salary cadence labels to exclude after extraction, for example hourly jobs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dedupeJobs": {
                        "title": "Deduplicate jobs",
                        "type": "boolean",
                        "description": "Skip duplicate jobs across pages and segmented searches.",
                        "default": true
                    },
                    "scrapeDetailPages": {
                        "title": "Scrape detail pages",
                        "type": "boolean",
                        "description": "Fetch each job page for description and richer apply/company data.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrent requests",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many Indeed pages to fetch in parallel.",
                        "default": 20
                    },
                    "requestDelayMillis": {
                        "title": "Request delay in milliseconds",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Optional delay after each successful request while holding a concurrency slot. Keep 0 for speed; raise it if Indeed starts rate limiting.",
                        "default": 0
                    },
                    "proxyUrl": {
                        "title": "Custom proxy URL",
                        "type": "string",
                        "description": "Optional proxy URL. Leave empty to use DEFAULT_PROXY_URL when configured, or Apify Proxy through proxyConfiguration."
                    },
                    "proxyConfiguration": {
                        "title": "Apify proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Defaults to Apify Proxy when no proxyUrl or DEFAULT_PROXY_URL is set.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "requestRetries": {
                        "title": "Request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry count for failed requests.",
                        "default": 2
                    },
                    "retryDelayMillis": {
                        "title": "Retry delay in milliseconds",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Delay between retry attempts after a failed request.",
                        "default": 1000
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout in seconds",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP timeout per request.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
