# ✅ Indeed Jobs Scraper API — Full Descriptions, Salary, No Login (`k1ra/indeed-jobs-scraper`) Actor

Scrape Indeed jobs without login. Full descriptions, salary, remote & date filters. n8n, Make, Zapier ready. Pay per result — $0 on empty. US, UK, India, Germany, Canada, Australia.

- **URL**: https://apify.com/k1ra/indeed-jobs-scraper.md
- **Developed by:** [Kevin Savani](https://apify.com/k1ra) (community)
- **Categories:** Jobs, Developer tools, MCP servers
- **Stats:** 10 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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 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 — Every Country · Full Descriptions · $0 on Empty

Scrape **Indeed jobs** in bulk with no login, no cookies, and no browser. Enter keywords and a location — the scraper works as an **Indeed jobs scraper with full job descriptions**, salary ranges, and all filters honored server-side. It routes to the correct Indeed regional domain for every country, deduplicates results, and enforces a hard result cap so runs never overcharge or stall. Use it as a **job board scraper API**, **job listing scraper**, or **job feed** builder — pipe structured **job posting data** into your platform, HR data pipeline, or automation workflow.

**Pay per result — pay per job delivered, and pay nothing when a search returns no results.**

---

### Why Choose This Indeed Jobs Scraper

- 🔓 **No login, no cookies, no browser** — works entirely over HTTP; your account is never involved.
- 🌍 **True global routing** — US, UK, India, Germany, Canada, Australia, and more. Not US-only.
- 📝 **Full job descriptions** — fetch the complete description text for every job (opt-in, failure-isolated).
- 💰 **Salary data included** — parsed min/max/currency + raw salary text from every listing that has it.
- 🎯 **Filters honored server-side** — date posted, job type, remote, salary minimum, and location — not applied after the fact.
- 🏙️ **Nationwide search** — city is optional. Leave it blank and the actor fans out across top cities automatically.
- 🛑 **No runaway runs** — `maxResults` is enforced exactly; the actor stops the moment it hits your cap.
- 💸 **Honest billing** — pay per delivered job, `$0` on empty runs, hard spend cap honored.
- 🧹 **Deduplication built-in** — stable job IDs, no duplicate postings across city/filter splits.
- 🔌 **Automation-ready** — n8n, Make, Zapier, scheduling, and a simple REST API.

---

### How It Compares

| Feature | **This Scraper** | Leading Indeed Scraper |
|---|:---:|:---:|
| Failure rate | ✅ low | ❌ fails ~28% of runs |
| No runaway runs | ✅ hard stop at `maxResults` | ❌ "impossible to make it stop" |
| Charged on empty results | ✅ `$0` | ❌ billed even for zero results |
| True global geo | ✅ US · UK · India · Germany · CA · AU | ❌ US-only; other countries return US results |
| City optional / nationwide | ✅ | ❌ city required; nationwide impossible |
| Full job descriptions | ✅ opt-in | ❌ not available |
| Filters honored server-side | ✅ | ❌ date filter often ignored |
| Salary extracted | ✅ min/max/currency | ⚠️ raw text only |
| n8n / Make / API ready | ✅ | ⚠️ varies |

---

### Use Cases

#### Indeed Scraper with Full Job Descriptions
Use this **Indeed scraper with full job descriptions** to extract complete posting text alongside title, company, salary, and location — ideal for LLM parsing, skills extraction, job-board ingestion, and candidate-facing portals. Enable `includeDescription` and each job returns the full description from its `viewjob` page.

#### Indeed Jobs Scraper API
Use it as an **Indeed jobs scraper API**: trigger runs via the Apify REST API or Python/JavaScript SDKs, pass your search parameters in the request body, and receive a structured JSON dataset. No Selenium, no browser, no scraping complexity — just an HTTP call.

#### Indeed Scraper for n8n and Make
Trigger from **n8n** (Apify node) or **Make** (Run Actor module), schedule recurring runs for fresh job feeds, and pipe results directly into Google Sheets, Airtable, Slack, or your ATS. The cleanest way to build a **job-alert bot** or **auto-apply pipeline** without writing code.

#### Indeed Scraper — UK Jobs (uk.indeed.com)
Search UK job listings on **uk.indeed.com** with full salary data in GBP. Set `country` to `UK` and the actor routes to the correct regional domain, resolves an exit IP in Great Britain, and returns salary ranges in the local currency. The fix for scrapers that say "UK" but return US results.

#### Indeed Scraper — India Jobs (in.indeed.com)
Scrape **India job listings** from **in.indeed.com** — full descriptions, salary in INR, job type, and date filters. Set `country` to `IN`. Ideal for India job boards, recruiters targeting the Indian market, and labor-market research across IT hubs like Bangalore, Hyderabad, and Mumbai.

#### Indeed Scraper — Germany Jobs (de.indeed.com)
Collect **Germany job listings** from **de.indeed.com**. Set `country` to `DE` for correct geo routing, salary in EUR, and German-language postings. Use it as a **Germany jobs scraper** for cross-border recruitment, DACH market research, and EU hiring dashboards.

#### Indeed Scraper — Canada & Australia Jobs
Route to **ca.indeed.com** (Canada) or **au.indeed.com** (Australia) by setting `country` to `CA` or `AU`. Same clean output — job ID, title, company, salary, job type, remote flag, and posting date — with the correct regional domain and a matching exit IP.

#### Indeed Jobs Scraper for Salary Research & Benchmarking
Pull salary data across roles, locations, and countries at scale. The actor extracts `salaryMin`, `salaryMax`, `currency`, and the raw `salaryText` from every listing that discloses it — ready for aggregation, benchmarking dashboards, and compensation band analysis.

#### Indeed Scraper — Nationwide / Global Search
Leave `location` blank for a **nationwide search**. The actor automatically fans out across top cities extracted from an initial sweep, merges results, and deduplicates by job ID — so you get broad coverage without manually listing cities. Use it for **global job market research** across any of the six supported regions.

#### Job Board Scraper API, Job Feed & Job Posting Aggregator

Use this **job scraper API** to power a job board, recruitment platform, or HR data pipeline. Each run returns structured JSON ready for ingestion — title, company, location, salary, job type, remote flag, URL, and optional full description. Schedule recurring runs to produce a live **job feed** with fresh **job posting** data every hour or daily. Works as a **job listing scraper**, **job posting scraper**, and **job aggregator** in a single actor — no browser, no parsing code, just clean **job data API** output.

#### Indeed Scraper for HR Data, Talent Intelligence & Salary Research

Pull **HR data** at scale: compensation benchmarks, skills-gap analysis, hiring velocity by location and sector, contract-vs-full-time ratios. The actor's clean output — `salaryMin`, `salaryMax`, `currency`, `jobType`, `remote` — feeds directly into BI dashboards, spreadsheets, or Python for labor-market analysis and salary benchmarking. Used by HR analytics teams, compensation consultants, and workforce researchers tracking **indeed salary scraper** outputs over time.

---

### Who Uses This

| Use Case | Who It's For |
|---|---|
| Job board & aggregator feeds | Job boards, ATS vendors, HR tech |
| Recruiting & talent sourcing | Recruiters, sourcers, staffing firms |
| Salary & labor-market research | Analysts, researchers, compensation teams |
| Job-alert automation (n8n / Make / Zapier) | Automation builders, indie hackers |
| Indeed scraper API integration | Developers building job apps and platforms |
| Lead generation from hiring signals | Sales & B2B prospecting teams |

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | string | — | Job search keywords (e.g. `software engineer`). **Required.** |
| `country` | enum | US | Country — routes to the correct Indeed domain (US, UK, IN, DE, CA, AU). |
| `location` | string | — | City or region (e.g. `London`). Leave empty for a nationwide search. |
| `remote` | boolean | false | Return only remote-tagged jobs. |
| `postedWithin` | enum | any | `24h` · `3d` · `7d` · `14d` · `any`. Honored server-side. |
| `jobType` | array | — | Employment type: `fulltime` (full-time jobs) · `contract` (contract jobs) · `parttime` · `internship` · `temporary`. Multiple types run in parallel and merge. |
| `salaryMin` | integer | — | Minimum annual salary (e.g. `80000`). |
| `maxResults` | integer | 100 | Hard cap — enforced exactly. Max 1000. |
| `includeDescription` | boolean | false | Fetch each job's full description page. |
| `dedupe` | boolean | true | Remove duplicates by job ID. |
| `maxCostUsd` | integer | — | Optional hard spend cap for the run. |
| `proxyConfiguration` | object | — | Residential proxy required (e.g. Apify Residential). |

#### Example input

```json
{
  "keywords": "data engineer",
  "country": "UK",
  "postedWithin": "7d",
  "jobType": ["fulltime"],
  "maxResults": 500,
  "includeDescription": true
}
````

***

### Output

Each dataset item is one Indeed job posting:

```json
{
  "jobId": "9b697ea78117c668",
  "title": "Senior Software Engineer",
  "company": "Acme Corp",
  "location": "Austin, TX 78701",
  "country": "US",
  "remote": false,
  "postedAt": "3 days ago",
  "jobUrl": "https://www.indeed.com/viewjob?jk=9b697ea78117c668",
  "sourceBoard": "indeed",
  "salaryMin": 140000,
  "salaryMax": 175000,
  "currency": "USD",
  "salaryText": "$140,000 - $175,000 a year",
  "jobType": "Full-time",
  "rating": 4.2,
  "description": "We are looking for a Senior Software Engineer to join…",
  "scrapedAt": "2026-06-13T10:00:00.000Z"
}
```

Core fields are always present. `description` is added when `includeDescription` is `true`. Salary fields appear when Indeed discloses them on the posting. Every job includes its public `jobUrl` for direct linking.

***

### Supported Countries

| Code | Domain | Region |
|---|---|---|
| US | indeed.com | United States |
| UK | uk.indeed.com | United Kingdom |
| IN | in.indeed.com | India |
| DE | de.indeed.com | Germany |
| CA | ca.indeed.com | Canada |
| AU | au.indeed.com | Australia |

***

### Pricing

**Pay per result — `$0` when a search returns nothing.** True pay-per-result billing: you pay only for the unique jobs you actually receive. No flat monthly fee, no charge for empty runs, no per-run floor. The hard `maxResults` cap means you always know the maximum cost before you run. At $0.002 per job, 1,000 jobs costs $2.

***

### Integrations & Indeed Automation

- **n8n** — Apify node → set Actor `k1ra/indeed-jobs-scraper` → pass `keywords` + `country` → connect output to your workflow.
- **Make** — Run Actor module → `k1ra/indeed-jobs-scraper` → map dataset items to Sheets, Airtable, or CRM.
- **Zapier** — Apify action → run actor → use results in any downstream Zap.
- **Webhooks** — configure an Apify webhook to POST dataset results to any endpoint the moment a run completes — no polling, no waiting. Ideal for **job alert automation** and real-time **indeed webhook** pipelines.
- **API & SDKs** — start runs and fetch the dataset via the Apify REST API or Python/JavaScript SDKs.
- **Scheduling** — run daily or weekly for fresh job feeds, role-alert automation, and **indeed automation** workflows.
- **Export** — Dataset → Export → CSV / Excel / JSON, or auto-export to Google Sheets.

#### Python example

```python
import apify_client

client = apify_client.ApifyClient("YOUR_API_TOKEN")
run = client.actor("k1ra/indeed-jobs-scraper").call(run_input={
    "keywords": "machine learning engineer",
    "country": "US",
    "postedWithin": "7d",
    "maxResults": 300,
    "includeDescription": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item.get("salaryText"))
```

***

### FAQ

**Does it require login or cookies?**
No. Indeed's mobile SERP is publicly accessible. No account, no cookies, and no risk of banning your Indeed account.

**Why is a residential proxy required?**
Indeed checks IP reputation via Cloudflare. Datacenter IPs are blocked. Use Apify Residential (set `useApifyProxy: true`) or provide your own residential proxy URL.

**What is the per-query job limit?**
Indeed's mobile endpoint caps at roughly 100 jobs per query URL. For larger searches, the actor fans out across cities and job types and deduplicates results — giving you significantly more than the per-URL cap.

**Is `maxResults` truly enforced?**
Yes. The actor stops the moment it reaches your cap. No extra pages fetched, no overcharging, no stalled runs.

**Can I search nationwide without specifying a city?**
Yes. Leave `location` blank. The actor performs a broad nationwide sweep and then fans out across the top cities found in results — no city list required.

**Does it work for Germany, India, Canada, and Australia?**
Yes. Set `country` to `DE`, `IN`, `CA`, or `AU` and the actor routes to the correct Indeed domain with a matching residential exit IP. Salaries are returned in local currency.

**Can I run it from n8n, Make, or the API?**
Yes. Trigger it from n8n or Make using the standard Apify node/module, or call the Apify REST API directly — actor ID `k1ra/indeed-jobs-scraper`.

**Is it legal?**
It extracts only publicly available job postings. You are responsible for compliance with Indeed's Terms of Service and applicable laws (GDPR, CCPA, etc.) when using the data.

***

### ⭐ Bookmark This Actor & Leave a Review

If this **Indeed jobs scraper** saves you time:

- **⭐ Star it** at the top of the page to bookmark it and help others find it.
- **📝 Leave a review** — even one sentence on your use case helps us prioritize the next filter or country.

Your bookmarks and reviews directly improve this actor's visibility across the Apify Store.

***

### Related Apify Actors

- [LinkedIn Jobs Scraper](https://apify.com/k1ra/linkedin-jobs-scraper) — LinkedIn job search, no cookies
- [Naukri Jobs Scraper](https://apify.com/k1ra/naukri-jobs-scraper) — India + Gulf jobs, AmbitionBox ratings
- [Job Scrapers](https://apify.com/store?search=job+scraper) — all job board scrapers on Apify
- [All Jobs Actors](https://apify.com/store?category=JOBS) — full Apify jobs catalog

***

### Support & Feedback

Found a bug or want a new filter, field, or country?

- **Open an issue** on the actor's Issues tab in the Apify Console.
- **Feature requests** are welcome — especially new countries, additional filters, and output fields.

# Actor input Schema

## `keywords` (type: `string`):

Job search keywords (e.g. software engineer). Required.

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

Routes to the correct Indeed regional site and a matching residential exit IP.

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

Optional city or region (e.g. New York, NY). Leave empty for a nationwide search — the actor fans out across cities automatically.

## `remote` (type: `boolean`):

Return only remote jobs.

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

Only return jobs posted within this window (honored server-side).

## `jobType` (type: `array`):

Filter by employment type. Multiple types are searched and merged.

## `salaryMin` (type: `integer`):

Optional minimum annual salary hint (e.g. 100000).

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

Maximum jobs to return. Enforced exactly — no runaway runs.

## `includeDescription` (type: `boolean`):

Fetch each job's page for the full description. Slower (one request per job).

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

Remove duplicate postings by job id.

## `maxCostUsd` (type: `integer`):

Optional hard spend cap for the run.

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

A residential proxy is required. Provide your own residential proxy URL here.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "country": "US",
  "remote": false,
  "postedWithin": "any",
  "maxResults": 100,
  "includeDescription": false,
  "dedupe": true
}
```

# Actor output Schema

## `jobId` (type: `string`):

Unique Indeed job key (jobkey parameter).

## `title` (type: `string`):

Job title.

## `company` (type: `string`):

Hiring company name.

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

Job location as shown on Indeed.

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

Country code (US, UK, DE, IN, CA, AU).

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

True when Indeed marks the posting as remote.

## `postedAt` (type: `string`):

Relative posting time as shown on Indeed (e.g. '3 days ago').

## `jobUrl` (type: `string`):

Public Indeed job view URL.

## `sourceBoard` (type: `string`):

Always 'indeed'.

## `description` (type: `string`):

Full job description text. Only when 'Include full descriptions' is enabled.

## `salaryMin` (type: `string`):

Minimum salary (annual, in local currency). Present when Indeed provides a salary range.

## `salaryMax` (type: `string`):

Maximum salary (annual, in local currency).

## `currency` (type: `string`):

Salary currency code (USD, GBP, EUR, INR …).

## `salaryText` (type: `string`):

Raw salary string as shown on Indeed.

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

Employment type (Full-time, Contract, Part-time …).

## `rating` (type: `string`):

Company rating from Indeed reviews (0–5).

## `scrapedAt` (type: `string`):

ISO 8601 UTC timestamp when the job was collected.

# 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 = {
    "keywords": "software engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("k1ra/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 = { "keywords": "software engineer" }

# Run the Actor and wait for it to finish
run = client.actor("k1ra/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 '{
  "keywords": "software engineer"
}' |
apify call k1ra/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "✅ Indeed Jobs Scraper API — Full Descriptions, Salary, No Login",
        "description": "Scrape Indeed jobs without login. Full descriptions, salary, remote & date filters. n8n, Make, Zapier ready. Pay per result — $0 on empty. US, UK, India, Germany, Canada, Australia.",
        "version": "0.1",
        "x-build-id": "BJoxoLswhbbY9PykZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/k1ra~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-k1ra-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/k1ra~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-k1ra-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/k1ra~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-k1ra-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job search keywords (e.g. software engineer). Required."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "IN",
                            "CA",
                            "AU"
                        ],
                        "type": "string",
                        "description": "Routes to the correct Indeed regional site and a matching residential exit IP.",
                        "default": "US"
                    },
                    "location": {
                        "title": "Location / city",
                        "type": "string",
                        "description": "Optional city or region (e.g. New York, NY). Leave empty for a nationwide search — the actor fans out across cities automatically."
                    },
                    "remote": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Return only remote jobs.",
                        "default": false
                    },
                    "postedWithin": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "24h",
                            "3d",
                            "7d",
                            "14d"
                        ],
                        "type": "string",
                        "description": "Only return jobs posted within this window (honored server-side).",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Job types",
                        "type": "array",
                        "description": "Filter by employment type. Multiple types are searched and merged.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fulltime",
                                "contract",
                                "parttime",
                                "internship",
                                "temporary"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Contract",
                                "Part-time",
                                "Internship",
                                "Temporary"
                            ]
                        }
                    },
                    "salaryMin": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum annual salary hint (e.g. 100000)."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs to return. Enforced exactly — no runaway runs.",
                        "default": 100
                    },
                    "includeDescription": {
                        "title": "Include full descriptions",
                        "type": "boolean",
                        "description": "Fetch each job's page for the full description. Slower (one request per job).",
                        "default": false
                    },
                    "dedupe": {
                        "title": "Deduplicate",
                        "type": "boolean",
                        "description": "Remove duplicate postings by job id.",
                        "default": true
                    },
                    "maxCostUsd": {
                        "title": "Max cost (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional hard spend cap for the run."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "A residential proxy is required. Provide your own residential proxy URL here."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
