# Indeed Jobs Scraper - Cheap and Fast (`fabri-lab/indeed-jobs-scraper`) Actor

Scrape fresh Indeed jobs with full descriptions, salaries, company data, apply links, country validation, duplicate removal, and hard cost limits

- **URL**: https://apify.com/fabri-lab/indeed-jobs-scraper.md
- **Developed by:** [Yusuf Barış](https://apify.com/fabri-lab) (community)
- **Categories:** Automation, Jobs
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🚀 Indeed Jobs Scraper for Job Boards

Scrape Indeed search-card job listings in fast `high_volume` mode, or open detail pages in slower `full_description` mode for best-effort full descriptions, richer company metadata, and external apply links when available.

Built for job boards, recruiters, HR teams, salary benchmarking, hiring trend analysis, and job market research.

### 💰 Normal Pricing

| Pricing item | Price |
|---|---:|
| Successful job listing | `$0.002` |
| 1,000 successful job listings | `$2.00` |
| Failed, skipped, duplicate, or detected wrong-country listings | `$0.00` |

✅ You only pay for successfully saved unique job listings.  
❌ Empty results, failed detail pages, duplicate jobs, filtered jobs, and detected country-mismatched jobs are not charged as listing events.

#### 💵 Price summary

| ✅ Charged | ❌ Not charged |
|---|---|
| Successfully saved unique job listings | Empty results |
| `$0.002` per successful job | Failed detail pages |
| `$2.00` per 1,000 successful jobs | Blocked detail pages |
|  | Duplicate jobs |
|  | Jobs skipped by filters |
|  | Jobs from the wrong country |

### ✨ What This Actor Does

| Capability | Included |
|---|---:|
| Search Indeed by position and location | ✅ |
| Multiple positions in one run | ✅ |
| Custom Indeed search URLs | ✅ |
| Indeed company jobs URLs | ✅ |
| 60+ Indeed country sites | ✅ |
| Full job descriptions when enabled | ✅ |
| Salary and salary type extraction | ✅ |
| Job type extraction | ✅ |
| Company name from search cards | ✅ |
| Company rating, reviews, logo, and URL in full description mode | ✅ |
| Posted date and freshness filter | ✅ |
| External apply link extraction when available | ✅ |
| Duplicate removal | ✅ |
| Best-effort country validation | ✅ |
| Hard total result limit | ✅ |
| Per-search result limit | ✅ |
| JSON, CSV, Excel, XML, and API export | ✅ |

### 🎯 Best For

| Use case | Example |
|---|---|
| Job boards | Fill or refresh job listings automatically |
| Recruiters | Monitor fresh openings by role and location |
| HR research | Track hiring activity and job demand |
| Salary analysis | Collect salary ranges by title, market, and country |
| Market intelligence | Watch competitor hiring trends |
| Data pipelines | Export structured job data through Apify API |

### 🌍 Country Coverage

This actor supports 60+ Indeed country sites, including the United States, United Kingdom, Canada, Australia, Germany, France, Netherlands, Spain, Italy, Turkey, India, Japan, Brazil, Mexico, Singapore, South Africa, and many more.

The actor validates country context using the selected country, Indeed country domain, source search location, and visible job location. Detected wrong-country, duplicate, skipped, blocked, or failed records are not charged as listing events.

### 📥 Input Example

```json
{
  "positions": ["web developer", "data analyst"],
  "country": "US",
  "location": "San Francisco",
  "maxJobsPerSearch": 100,
  "maxJobsTotal": 300,
  "postedWithin": "last_7_days",
  "scrapeMode": "high_volume",
  "scrapeCompanyDetails": true,
  "followApplyRedirects": true,
  "saveOnlyUniqueJobs": true,
  "excludeHourlySalary": false,
  "salaryType": "any",
  "jobType": "any",
  "customSearchUrls": [],
  "companyJobsUrls": []
}
````

### 📤 Output Example

```json
{
  "jobId": "24e1fe226a1412b8",
  "positionName": "Web Developer",
  "company": "Example Company",
  "companyUrl": "https://www.indeed.com/cmp/example-company",
  "companyLogo": null,
  "companyRating": null,
  "companyReviewsCount": null,
  "location": "San Francisco, CA",
  "country": "US",
  "salary": "$80,000 - $110,000 a year",
  "salaryType": "annual",
  "jobType": ["Full-time", "Remote"],
  "postedAt": "1 day ago",
  "postedAtDate": "2026-05-11",
  "isFresh": true,
  "url": "https://www.indeed.com/viewjob?jk=24e1fe226a1412b8",
  "externalApplyLink": null,
  "description": "",
  "descriptionHTML": null,
  "hasDescription": false,
  "validation": {
    "countryMatched": true,
    "locationMatched": true,
    "locationSource": "listing"
  },
  "sourceSearch": {
    "position": "web developer",
    "location": "San Francisco",
    "country": "US"
  },
  "scrapedAt": "2026-05-12T12:00:00.000Z"
}
```

### 🧾 Pay-Per-Event Setup

| Setting | Value |
|---|---|
| Pricing model | Pay per event |
| Event name | `successful-job-listing` |
| Event price | `$0.002` |
| Public price | `$2.00 per 1,000 successful job listings` |

Pricing assumes Apify pay-per-event is configured for `successful-job-listing`. `maxJobsTotal` caps saved listing events, not pages opened or attempted requests.

### 🛡️ Cost Safety

| Limit | What it does |
|---|---|
| `maxJobsPerSearch` | Limits saved or queued candidates for each position/search URL. Saved jobs may be lower after filters, duplicates, blocked pages, missing descriptions, or country validation |
| `maxJobsTotal` | Hard stop for the whole run |
| `saveOnlyUniqueJobs` | Prevents duplicate saved listings |
| Best-effort country validation | Skips detected jobs that do not match the selected country |

You are not charged for:

- Empty results
- Failed job detail pages
- Blocked detail pages
- Duplicate jobs
- Jobs skipped by filters
- Jobs without descriptions in full description mode
- Jobs detected as being from the wrong country

### ⚡ Performance Notes

By default, `scrapeMode` is `high_volume`. The actor saves jobs directly from Indeed search cards. This is the fastest and most reliable mode for collecting larger datasets.

When `scrapeMode` is `full_description`, the actor opens each Indeed job detail page to collect the full description. Indeed can return `401`, `403`, or `429` for some detail pages even with residential proxies.

Those blocked detail pages are skipped, counted in the run summary, and not charged.

For faster test runs:

| Setting | Recommended test value |
|---|---:|
| `maxJobsPerSearch` | `20` |
| `maxJobsTotal` | `50` |
| `postedWithin` | `last_7_days` |
| `scrapeMode` | `high_volume` for more results, `full_description` only when full descriptions are required |

### 🕒 Fresh Job Filtering

| Filter | Meaning |
|---|---|
| `last_24_hours` | Jobs posted in the last 24 hours |
| `last_3_days` | Jobs posted in the last 3 days |
| `last_7_days` | Jobs posted in the last 7 days |
| `last_14_days` | Jobs posted in the last 14 days |
| `any_time` | No freshness filter |

Freshness filtering applies Indeed's date filter and post-filters parseable dates. Listings with unknown posted dates may be kept.

### 🏪 Store Listing Copy

#### Short description

Scrape Indeed search-card job listings in fast high-volume mode, or open detail pages for best-effort full descriptions, richer company metadata, and apply links. Pay only for successfully saved unique job listings.

#### SEO title

Indeed Jobs Scraper for Job Boards with Full Descriptions

#### SEO description

Scrape fresh Indeed job listings with salaries, company data, locations, posted dates, job types, apply links, optional full descriptions, best-effort country validation, duplicate removal, and hard result limits. Price: $2 per 1,000 successful job listings.

#### Long description

Indeed Jobs Scraper for Job Boards helps you collect structured Indeed job listings for job boards, recruiting workflows, HR analytics, salary benchmarking, and market research. Search by position and location, use multiple keywords in one run, scrape custom Indeed search URLs, or collect listings from Indeed company jobs pages.

The actor extracts job titles, companies, locations, salaries, salary types, job types, posted dates, source URLs, and full descriptions, richer company metadata, and apply links when full-description mode is enabled. Built-in best-effort country validation, duplicate removal, freshness filters, per-search limits, and total result limits help keep datasets clean and predictable.

💰 Pricing is pay-per-successful-listing: $0.002 per saved unique job, equal to $2.00 per 1,000 successful job listings. Failed, skipped, duplicate, filtered, blocked, empty, or detected wrong-country results are not charged as listing events.

### ⚖️ Notes

Indeed pages and search behavior may change over time. Result counts can vary depending on country, location, keyword, filters, proxy availability, and Indeed availability.

This actor extracts publicly available job listing data only. It does not scrape private user data, resumes, or applicant information.

# Actor input Schema

## `positions` (type: `array`):

Enter one or more job titles, roles, or keywords to search on Indeed. Provide at least one of positions, customSearchUrls, or companyJobsUrls.

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

Select the Indeed country site to search. Results from other countries will be skipped and not charged.

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

Enter a city, state, region, or remote keyword.

## `maxJobsPerSearch` (type: `integer`):

Limit applied separately to each position/search URL. Saved jobs may be lower after filters, duplicates, blocked pages, missing descriptions, or country validation.

## `maxJobsTotal` (type: `integer`):

Hard stop for the whole run. Use this to control maximum cost.

## `postedWithin` (type: `string`):

Applies Indeed's date filter and post-filters parseable dates. Listings with unknown posted dates may be kept.

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

High volume saves jobs from Indeed search cards and avoids most detail-page blocks. Full descriptions opens every job detail page and can save fewer jobs if Indeed blocks those pages.

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

Best-effort company rating, reviews count, logo, and company URL extraction in full\_description mode.

## `followApplyRedirects` (type: `boolean`):

Best-effort external apply link resolution in full\_description mode when Indeed exposes an apply link.

## `saveOnlyUniqueJobs` (type: `boolean`):

Remove duplicate job listings from the dataset.

## `excludeHourlySalary` (type: `boolean`):

Skip jobs that appear to use hourly salary.

## `salaryType` (type: `string`):

Keep jobs matching this salary type.

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

Keep jobs matching this job type.

## `customSearchUrls` (type: `array`):

Indeed search URLs to scrape directly. Provide at least one of positions, customSearchUrls, or companyJobsUrls.

## `companyJobsUrls` (type: `array`):

Indeed company jobs URLs such as https://www.indeed.com/cmp/Google/jobs. Provide at least one of positions, customSearchUrls, or companyJobsUrls.

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

Proxy settings. Residential Apify Proxy is recommended for Indeed. If residential proxies are not available, the actor falls back to automatic Apify Proxy.

## Actor input object example

```json
{
  "positions": [
    "mekatronik"
  ],
  "country": "TR",
  "location": "",
  "maxJobsPerSearch": 5,
  "maxJobsTotal": 5,
  "postedWithin": "any_time",
  "scrapeMode": "high_volume",
  "scrapeCompanyDetails": true,
  "followApplyRedirects": true,
  "saveOnlyUniqueJobs": true,
  "excludeHourlySalary": false,
  "salaryType": "any",
  "jobType": "any",
  "customSearchUrls": [],
  "companyJobsUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `jobListings` (type: `string`):

No description

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

No description

# 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 = {
    "positions": [
        "mekatronik"
    ],
    "country": "TR",
    "location": "",
    "maxJobsPerSearch": 5,
    "maxJobsTotal": 5,
    "postedWithin": "any_time"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabri-lab/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 = {
    "positions": ["mekatronik"],
    "country": "TR",
    "location": "",
    "maxJobsPerSearch": 5,
    "maxJobsTotal": 5,
    "postedWithin": "any_time",
}

# Run the Actor and wait for it to finish
run = client.actor("fabri-lab/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 '{
  "positions": [
    "mekatronik"
  ],
  "country": "TR",
  "location": "",
  "maxJobsPerSearch": 5,
  "maxJobsTotal": 5,
  "postedWithin": "any_time"
}' |
apify call fabri-lab/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper - Cheap and Fast",
        "description": "Scrape fresh Indeed jobs with full descriptions, salaries, company data, apply links, country validation, duplicate removal, and hard cost limits",
        "version": "0.0",
        "x-build-id": "7KgeL6xINuJuxSNGh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabri-lab~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabri-lab-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/fabri-lab~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fabri-lab-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/fabri-lab~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fabri-lab-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",
                "required": [
                    "country"
                ],
                "properties": {
                    "positions": {
                        "title": "Positions / keywords",
                        "type": "array",
                        "description": "Enter one or more job titles, roles, or keywords to search on Indeed. Provide at least one of positions, customSearchUrls, or companyJobsUrls.",
                        "default": [
                            "mekatronik"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "AE",
                            "AR",
                            "AT",
                            "AU",
                            "BE",
                            "BH",
                            "BR",
                            "CA",
                            "CH",
                            "CL",
                            "CN",
                            "CO",
                            "CR",
                            "CZ",
                            "DE",
                            "DK",
                            "EC",
                            "EG",
                            "ES",
                            "FI",
                            "FR",
                            "GB",
                            "GR",
                            "HK",
                            "HU",
                            "ID",
                            "IE",
                            "IL",
                            "IN",
                            "IT",
                            "JP",
                            "KR",
                            "KW",
                            "LU",
                            "MA",
                            "MX",
                            "MY",
                            "NG",
                            "NL",
                            "NO",
                            "NZ",
                            "OM",
                            "PA",
                            "PE",
                            "PH",
                            "PK",
                            "PL",
                            "PT",
                            "QA",
                            "RO",
                            "SA",
                            "SE",
                            "SG",
                            "TH",
                            "TR",
                            "TW",
                            "UA",
                            "US",
                            "UY",
                            "VE",
                            "VN",
                            "ZA"
                        ],
                        "type": "string",
                        "description": "Select the Indeed country site to search. Results from other countries will be skipped and not charged.",
                        "default": "TR"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Enter a city, state, region, or remote keyword.",
                        "default": ""
                    },
                    "maxJobsPerSearch": {
                        "title": "Maximum jobs per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Limit applied separately to each position/search URL. Saved jobs may be lower after filters, duplicates, blocked pages, missing descriptions, or country validation.",
                        "default": 5
                    },
                    "maxJobsTotal": {
                        "title": "Maximum jobs total",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard stop for the whole run. Use this to control maximum cost.",
                        "default": 5
                    },
                    "postedWithin": {
                        "title": "Posted within",
                        "enum": [
                            "last_24_hours",
                            "last_3_days",
                            "last_7_days",
                            "last_14_days",
                            "any_time"
                        ],
                        "type": "string",
                        "description": "Applies Indeed's date filter and post-filters parseable dates. Listings with unknown posted dates may be kept.",
                        "default": "any_time"
                    },
                    "scrapeMode": {
                        "title": "Scrape mode",
                        "enum": [
                            "high_volume",
                            "full_description"
                        ],
                        "type": "string",
                        "description": "High volume saves jobs from Indeed search cards and avoids most detail-page blocks. Full descriptions opens every job detail page and can save fewer jobs if Indeed blocks those pages.",
                        "default": "high_volume"
                    },
                    "scrapeCompanyDetails": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "Best-effort company rating, reviews count, logo, and company URL extraction in full_description mode.",
                        "default": true
                    },
                    "followApplyRedirects": {
                        "title": "Follow apply redirects",
                        "type": "boolean",
                        "description": "Best-effort external apply link resolution in full_description mode when Indeed exposes an apply link.",
                        "default": true
                    },
                    "saveOnlyUniqueJobs": {
                        "title": "Save only unique jobs",
                        "type": "boolean",
                        "description": "Remove duplicate job listings from the dataset.",
                        "default": true
                    },
                    "excludeHourlySalary": {
                        "title": "Exclude hourly salary",
                        "type": "boolean",
                        "description": "Skip jobs that appear to use hourly salary.",
                        "default": false
                    },
                    "salaryType": {
                        "title": "Salary type",
                        "enum": [
                            "any",
                            "hourly",
                            "annual",
                            "monthly",
                            "unknown"
                        ],
                        "type": "string",
                        "description": "Keep jobs matching this salary type.",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "any",
                            "full_time",
                            "part_time",
                            "contract",
                            "temporary",
                            "internship",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Keep jobs matching this job type.",
                        "default": "any"
                    },
                    "customSearchUrls": {
                        "title": "Custom Indeed search URLs",
                        "type": "array",
                        "description": "Indeed search URLs to scrape directly. Provide at least one of positions, customSearchUrls, or companyJobsUrls.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyJobsUrls": {
                        "title": "Company jobs URLs",
                        "type": "array",
                        "description": "Indeed company jobs URLs such as https://www.indeed.com/cmp/Google/jobs. Provide at least one of positions, customSearchUrls, or companyJobsUrls.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential Apify Proxy is recommended for Indeed. If residential proxies are not available, the actor falls back to automatic Apify Proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
