# Indeed Jobs Scraper | Real-Time Job Listings API (`b2b_leads/indeed-job-real-time-data-scraper`) Actor

Indeed job scraper for recruiters & job boards. Collect real-time postings by keyword, location, company & URL. Full descriptions, salary, filters, structured JSON. Hiring data for market research, talent sourcing, AI agents, Zapier & webhooks. Fast parallel Apify actor.

- **URL**: https://apify.com/b2b\_leads/indeed-job-real-time-data-scraper.md
- **Developed by:** [Chidubem Aneke](https://apify.com/b2b_leads) (community)
- **Categories:** Jobs, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 jobs

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

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 Job Real-Time Data

**The fastest way to collect Indeed job postings on Apify.** Turn any job search into clean, structured JSON — ready for spreadsheets, dashboards, automations, and AI workflows. Results land in your dataset **in real time**, as each job is found.

Built for recruiters, talent teams, job boards, market researchers, and builders who need **reliable hiring data at scale** — without slow setups or messy exports.

---

### Why this Actor

| | Indeed Job Real-Time Data | Typical job data tool |
|---|---------------------------|------------------------|
| **Speed** | ~1–3 s per job | 5–15 s per job |
| **Memory** | **256–512 MB** default | 2–4 GB+ |
| **Setup** | Run in seconds | Often complex configuration |
| **Cost** | Low compute, efficient runs | High |
| **Output** | Structured JSON, LLM-ready | Often messy or incomplete |
| **Scale** | Up to **1,000 jobs** per keyword | Often capped lower |
| **Filters** | Full Indeed Jobs filters | Often keyword-only |
| **Modes** | Search · Company jobs · Job links | Usually one mode only |

---

### Three ways to collect jobs

| Mode | What it does | Best for |
|------|--------------|----------|
| **Job search** | Keyword + location search with full Indeed filters | Market scans, role tracking, location-based hiring |
| **Company jobs** | All open roles from specific employers | Competitor monitoring, account-based recruiting |
| **Job links** | Structured data from individual Indeed job URLs | Enriching a list you already have |

Enable one or combine all three in a single run.

---

### What you get — every job, fully structured

Each record is one job posting with `featureType`, `jobKey`, and `scrapedAt` so you can sort, filter, and join with your own data.

| Field | What it tells you |
|-------|-------------------|
| `title`, `company`, `location`, `workplaceType` | Role, employer, place, remote/hybrid/onsite |
| `jobUrl`, `applyUrl`, `companyUrl`, `companyLogo` | Direct links and company branding |
| `descriptionText`, `descriptionHtml` | Full job description (when detail fetch is on) |
| `seniorityLevel`, `employmentType`, `jobFunction` | How the role is classified |
| `salary`, `benefits`, `applicantCount`, `indeedApply` | Compensation signals, perks, and competition |
| `companyRating`, `companyReviewCount` | Employer reputation on Indeed |
| `listedAtISO`, `postedTimeAgo` | How fresh the listing is |
| `searchQuery`, `searchLocation`, `searchCompany`, `position` | Which search produced this row and its rank |
| `sponsored`, `newJob` | Listing signals from Indeed |

Set `includeRaw: true` if you need extended record data for custom processing.

**`featureType` values:** `job` (search) · `company_job` (company jobs) · `scrape_by_url` (job links)

---

### Search like Indeed Jobs — get data like a database

Use the **same filters job seekers use on Indeed**:

- **Keywords** — one search per keyword (e.g. `warehouse`, `registered nurse`)
- **Title** — narrow to a specific role name
- **Company** — jobs at Amazon, Walmart, or any employer
- **Location** — United States, Ohio, New York, Remote, and more
- **Experience level** — entry, mid, senior
- **Employment type** — full-time, part-time, contract, temporary, internship
- **Workplace** — on-site, remote, hybrid
- **Date posted** — any time, past month, week, 3 days, or 24 hours
- **Sort** — relevance or most recent
- **Radius** — miles around your location
- **Volume** — up to **1,000 jobs per keyword**
- **Full details** — toggle rich descriptions, benefits, and applicant counts on or off

---

### Use cases — real outcomes

- **Recruiting pipelines** — build candidate-ready job lists by role, location, and seniority
- **Job boards and aggregators** — feed your product with fresh Indeed listings daily
- **Market and salary research** — track who is hiring, where, and for what skills
- **Competitive intelligence** — monitor competitor hiring by company and function
- **Sales and BD** — spot companies in hiring mode for timely outreach
- **Staffing agencies** — track demand by region, role, and employer
- **AI assistants and agents** — summarize listings, score fit, draft outreach, or answer hiring questions
- **Data warehouses and CRMs** — push JSON into Snowflake, BigQuery, HubSpot, Airtable, or your stack via API

---

### LLM and MCP integration

Output is **structured JSON** — ideal for ChatGPT, Claude, Gemini, LangChain, LlamaIndex, CrewAI, and custom agents. No cleanup step. No manual formatting. Just records your model can read.

#### Recommended workflow

1. Run the Actor with your keywords, companies, or job links.
2. Pull dataset items via [Apify API](https://docs.apify.com/api/v2), webhook, or export JSON/CSV.
3. Pass records to your LLM, vector store, or automation — one job per row.

#### Example: one job record for an LLM prompt

```json
{
  "featureType": "job",
  "jobKey": "a22fa26470cfb9ad",
  "title": "Warehouse Supervisor",
  "company": "Tire Discounters",
  "location": "Cincinnati, OH 45241",
  "workplaceType": "On-site",
  "employmentType": "Full-time",
  "descriptionText": "The Warehouse Supervisor is responsible for overseeing receiving, stocking and distribution...",
  "salary": "$18 - $22 an hour",
  "benefits": ["Health insurance", "401(k)"],
  "applicantCount": 12,
  "indeedApply": true,
  "companyRating": 2.9,
  "listedAtISO": "2026-07-07T05:00:00.000Z",
  "postedTimeAgo": "2 days ago",
  "jobUrl": "https://www.indeed.com/viewjob?jk=a22fa26470cfb9ad",
  "searchQuery": "warehouse",
  "searchLocation": "Ohio",
  "position": 1,
  "scrapedAt": "2026-07-11T12:00:00.000Z"
}
````

#### Apify MCP (Model Context Protocol)

Connect the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants can:

- **Run** this Actor from natural-language instructions
- **Read** job results directly in the chat
- **Chain** with other Actors — enrich contacts, send alerts, update spreadsheets

**Example MCP conversation:**

```
User: "Find 50 warehouse jobs in Ohio posted this week and summarize top employers"

→ MCP runs Indeed Job Real-Time Data with jobKeywords, jobLocation=Ohio, jobDatePosted=week
→ MCP reads dataset items
→ LLM summarizes hiring trends and top companies
```

#### API quick start

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "enableJobSearch": true,
    "jobKeywords": ["warehouse"],
    "jobLocation": "Ohio",
    "jobDatePosted": "week",
    "jobsPerQuery": 50,
    "fetchJobDetails": true
  }'
```

**Fetch results:** `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`

**Dataset views in Apify Console:** Overview (core fields) and Full details (includes descriptions)

Export as **JSON**, **CSV**, **Excel**, **RSS**, or via **API**.

***

### Input reference

#### Job search

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableJobSearch` | boolean | `true` | Turn keyword search on or off |
| `jobKeywords` | string\[] | `["software engineer"]` | Search keywords — one run per keyword |
| `jobTitle` | string | — | Title filter |
| `jobCompany` | string | — | Company filter |
| `jobLocation` | string | `"United States"` | Location |
| `jobExperienceLevels` | enum\[] | all | entry\_level, mid\_level, senior\_level |
| `jobTypes` | enum\[] | all | fulltime, parttime, contract, temporary, internship |
| `jobRemote` | enum\[] | all | onsite, remote, hybrid |
| `jobDatePosted` | enum | `any` | any, month, week, 3days, day |
| `jobSort` | enum | `relevance` | relevance or date |
| `jobsPerQuery` | integer | `25` | Max jobs per keyword (1–1000) |
| `radiusMiles` | integer | `25` | Search radius in miles (0–100) |

#### Company jobs

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableCompanyJobs` | boolean | `false` | Collect jobs from company profiles |
| `companyNames` | string\[] | `[]` | Company names (e.g. Amazon, Target) |
| `jobsPerCompany` | integer | `25` | Max jobs per company (1–1000) |

#### Job links

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableScrapeByUrl` | boolean | `false` | Collect data from individual job links |
| `jobUrls` | string\[] | `[]` | Indeed job page URLs |

#### Output and global

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `fetchJobDetails` | boolean | `true` | Full description, benefits, applicant count |
| `includeRaw` | boolean | `false` | Attach extended record data |
| `webhookUrl` | string | — | Optional URL for real-time record delivery (Zapier, Slack, CRM) |
| `webhookFormat` | enum | `json` | `json` (full record) or `slack` (message) |
| `country` | string | `us` | Target country market (us, uk, ca, …) |
| `maxItems` | integer | `10000` | Max total records across all modes |
| `proxyConfiguration` | object | residential US | Connection settings (US residential recommended) |

Full schema: **Input** tab on Apify Console or `.actor/input_schema.json` in this repository.

***

### Quick start examples

**Warehouse roles in Ohio — full details**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["warehouse"],
  "jobLocation": "Ohio",
  "jobDatePosted": "week",
  "jobSort": "date",
  "jobsPerQuery": 50,
  "fetchJobDetails": true
}
```

**Jobs at a specific company**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["associate"],
  "jobCompany": "Amazon",
  "jobLocation": "United States",
  "jobsPerQuery": 100
}
```

**All jobs from employer profiles**

```json
{
  "enableCompanyJobs": true,
  "companyNames": ["Amazon", "Walmart", "Target"],
  "jobsPerCompany": 50,
  "fetchJobDetails": true
}
```

**Import specific job links**

```json
{
  "enableScrapeByUrl": true,
  "jobUrls": [
    "https://www.indeed.com/viewjob?jk=YOUR_JOB_KEY"
  ],
  "fetchJobDetails": true
}
```

**Fresh listings only — fast summary mode**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["nurse"],
  "jobLocation": "Dallas, TX",
  "jobDatePosted": "day",
  "jobSort": "date",
  "jobsPerQuery": 75,
  "fetchJobDetails": false
}
```

**High-volume market scan**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["machine learning", "data scientist", "AI engineer"],
  "jobLocation": "United States",
  "jobExperienceLevels": ["mid_level", "senior_level"],
  "jobsPerQuery": 500,
  "fetchJobDetails": true
}
```

***

### Performance and reliability

- **Residential proxy (US recommended)** — best results and consistent throughput.
- **Default memory: 512 MB** — enough for high-volume runs with multiple keywords and companies.
- **Streaming output** — each job is written to the dataset immediately; nothing is buffered in memory for long runs.
- **Webhook delivery** — optionally POST each new record to your URL in real time (dataset is always the primary output).
- **Smart search expansion** — automatically broadens coverage when you request large result sets.
- **Parallel processing** — multiple keywords, companies, and job details run concurrently for faster results at 512 MB memory.

***

### Limitations and compliance

- This is an unofficial tool — not affiliated with Indeed.
- Use responsibly and comply with applicable laws and Indeed's Terms of Service.
- Some fields (e.g. salary, benefits) appear only when employers publish them.
- Listing availability can change; expired postings may return summary data only.

***

### Contact and custom work

Need something beyond this Actor? I design and build **custom data solutions** and **full-stack products** for teams that want results — not experiments.

**Email:** <dubem115@gmail.com>\
**GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Reach out for:

- **Custom Apify Actors** — any website, job board, or data source
- **Indeed and hiring data projects** — pipelines, alerts, and dashboards at scale
- **LLM and MCP integrations** — connect your data to ChatGPT, Claude, and agent workflows
- **Web apps and automation** — data tools, internal platforms, SaaS products, and client-facing apps
- **Any scraping project** — lead generation, market research, monitoring, and enrichment at scale

Whether you need a one-off data feed or a production system, I can help you ship it.

***

*Indeed Job Real-Time Data · by [DrunkCodes](https://github.com/DrunkCodes)*

# Actor input Schema

## `enableJobSearch` (type: `boolean`):

Search Indeed Jobs by keyword, title, company, and location with filters.

## `jobKeywords` (type: `array`):

Main job search keywords — same as the Indeed Jobs search box. One search per keyword.

## `jobTitle` (type: `string`):

Title filter (e.g. "Software Engineer"). Combined with keywords for more precise results.

## `jobCompany` (type: `string`):

Company filter — search jobs at a specific company (e.g. "Amazon", "Walmart"). Leave empty for any company.

## `jobLocation` (type: `string`):

Location to search jobs in (e.g. "United States", "New York, NY", "Remote").

## `jobExperienceLevels` (type: `array`):

Filter jobs by experience level.

## `jobTypes` (type: `array`):

Filter jobs by employment type.

## `jobRemote` (type: `array`):

Filter jobs by on-site, remote, or hybrid.

## `jobDatePosted` (type: `string`):

Only return jobs posted within this window.

## `jobSort` (type: `string`):

Relevance or most recent.

## `jobsPerQuery` (type: `integer`):

Maximum jobs to return per keyword (1–1000).

## `radiusMiles` (type: `integer`):

Radius around the location for job search.

## `enableCompanyJobs` (type: `boolean`):

Collect open positions from specific employers on Indeed.

## `companyNames` (type: `array`):

Employer names as listed on Indeed (e.g. "Amazon", "Target", "FedEx").

## `jobsPerCompany` (type: `integer`):

Maximum jobs to return per company (1–1000).

## `enableScrapeByUrl` (type: `boolean`):

Collect structured data from individual Indeed job page links.

## `jobUrls` (type: `array`):

Indeed job page URLs you want to collect.

## `fetchJobDetails` (type: `boolean`):

Include each job's full description, benefits, and applicant count. Slightly slower but much richer.

## `includeRaw` (type: `boolean`):

Attach extended record data under the raw field. Larger output.

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an additional real-time push. When set, each new record is also sent to this URL (CRM, Slack, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

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

Target country market (e.g. us, uk, ca, au, de, fr).

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

Maximum total job records across all enabled modes.

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

Residential US proxy recommended for best results and consistent throughput.

## Actor input object example

```json
{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobTitle": "",
  "jobCompany": "",
  "jobLocation": "United States",
  "jobExperienceLevels": [],
  "jobTypes": [],
  "jobRemote": [
    "onsite",
    "remote",
    "hybrid"
  ],
  "jobDatePosted": "any",
  "jobSort": "relevance",
  "jobsPerQuery": 25,
  "radiusMiles": 25,
  "enableCompanyJobs": false,
  "companyNames": [],
  "jobsPerCompany": 25,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "fetchJobDetails": true,
  "includeRaw": false,
  "webhookUrl": "",
  "webhookFormat": "json",
  "country": "us",
  "maxItems": 10000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every job field from this run.

## `overview` (type: `string`):

Core job fields table view.

## `full` (type: `string`):

All job fields including descriptions.

# 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 = {
    "enableJobSearch": true,
    "jobKeywords": [
        "software engineer"
    ],
    "jobTitle": "",
    "jobCompany": "",
    "jobLocation": "United States",
    "jobExperienceLevels": [],
    "jobTypes": [],
    "jobRemote": [
        "onsite",
        "remote",
        "hybrid"
    ],
    "jobDatePosted": "any",
    "jobSort": "relevance",
    "jobsPerQuery": 25,
    "radiusMiles": 25,
    "enableCompanyJobs": false,
    "companyNames": [],
    "jobsPerCompany": 25,
    "enableScrapeByUrl": false,
    "jobUrls": [],
    "fetchJobDetails": true,
    "includeRaw": false,
    "webhookUrl": "",
    "country": "us",
    "maxItems": 10000
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/indeed-job-real-time-data-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 = {
    "enableJobSearch": True,
    "jobKeywords": ["software engineer"],
    "jobTitle": "",
    "jobCompany": "",
    "jobLocation": "United States",
    "jobExperienceLevels": [],
    "jobTypes": [],
    "jobRemote": [
        "onsite",
        "remote",
        "hybrid",
    ],
    "jobDatePosted": "any",
    "jobSort": "relevance",
    "jobsPerQuery": 25,
    "radiusMiles": 25,
    "enableCompanyJobs": False,
    "companyNames": [],
    "jobsPerCompany": 25,
    "enableScrapeByUrl": False,
    "jobUrls": [],
    "fetchJobDetails": True,
    "includeRaw": False,
    "webhookUrl": "",
    "country": "us",
    "maxItems": 10000,
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/indeed-job-real-time-data-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 '{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobTitle": "",
  "jobCompany": "",
  "jobLocation": "United States",
  "jobExperienceLevels": [],
  "jobTypes": [],
  "jobRemote": [
    "onsite",
    "remote",
    "hybrid"
  ],
  "jobDatePosted": "any",
  "jobSort": "relevance",
  "jobsPerQuery": 25,
  "radiusMiles": 25,
  "enableCompanyJobs": false,
  "companyNames": [],
  "jobsPerCompany": 25,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "fetchJobDetails": true,
  "includeRaw": false,
  "webhookUrl": "",
  "country": "us",
  "maxItems": 10000
}' |
apify call b2b_leads/indeed-job-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper | Real-Time Job Listings API",
        "description": "Indeed job scraper for recruiters & job boards. Collect real-time postings by keyword, location, company & URL. Full descriptions, salary, filters, structured JSON. Hiring data for market research, talent sourcing, AI agents, Zapier & webhooks. Fast parallel Apify actor.",
        "version": "0.0",
        "x-build-id": "p1Hc3Od5dXxhBlkzs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_leads~indeed-job-real-time-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_leads-indeed-job-real-time-data-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/b2b_leads~indeed-job-real-time-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-b2b_leads-indeed-job-real-time-data-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/b2b_leads~indeed-job-real-time-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_leads-indeed-job-real-time-data-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": {
                    "enableJobSearch": {
                        "title": "Job search",
                        "type": "boolean",
                        "description": "Search Indeed Jobs by keyword, title, company, and location with filters.",
                        "default": true
                    },
                    "jobKeywords": {
                        "title": "Job keywords",
                        "type": "array",
                        "description": "Main job search keywords — same as the Indeed Jobs search box. One search per keyword.",
                        "default": [
                            "software engineer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTitle": {
                        "title": "Job title",
                        "type": "string",
                        "description": "Title filter (e.g. \"Software Engineer\"). Combined with keywords for more precise results.",
                        "default": ""
                    },
                    "jobCompany": {
                        "title": "Company",
                        "type": "string",
                        "description": "Company filter — search jobs at a specific company (e.g. \"Amazon\", \"Walmart\"). Leave empty for any company.",
                        "default": ""
                    },
                    "jobLocation": {
                        "title": "Job location",
                        "type": "string",
                        "description": "Location to search jobs in (e.g. \"United States\", \"New York, NY\", \"Remote\").",
                        "default": "United States"
                    },
                    "jobExperienceLevels": {
                        "title": "Experience levels",
                        "type": "array",
                        "description": "Filter jobs by experience level.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "entry_level",
                                "mid_level",
                                "senior_level"
                            ],
                            "enumTitles": [
                                "Entry level",
                                "Mid level",
                                "Senior level"
                            ]
                        },
                        "default": []
                    },
                    "jobTypes": {
                        "title": "Job types",
                        "type": "array",
                        "description": "Filter jobs by employment type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fulltime",
                                "parttime",
                                "contract",
                                "temporary",
                                "internship"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Temporary",
                                "Internship"
                            ]
                        },
                        "default": []
                    },
                    "jobRemote": {
                        "title": "Workplace type",
                        "type": "array",
                        "description": "Filter jobs by on-site, remote, or hybrid.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "onsite",
                                "remote",
                                "hybrid"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Remote",
                                "Hybrid"
                            ]
                        },
                        "default": [
                            "onsite",
                            "remote",
                            "hybrid"
                        ]
                    },
                    "jobDatePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "month",
                            "week",
                            "3days",
                            "day"
                        ],
                        "type": "string",
                        "description": "Only return jobs posted within this window.",
                        "default": "any"
                    },
                    "jobSort": {
                        "title": "Sort jobs by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Relevance or most recent.",
                        "default": "relevance"
                    },
                    "jobsPerQuery": {
                        "title": "Jobs per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs to return per keyword (1–1000).",
                        "default": 25
                    },
                    "radiusMiles": {
                        "title": "Search radius (miles)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Radius around the location for job search.",
                        "default": 25
                    },
                    "enableCompanyJobs": {
                        "title": "Company jobs",
                        "type": "boolean",
                        "description": "Collect open positions from specific employers on Indeed.",
                        "default": false
                    },
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Employer names as listed on Indeed (e.g. \"Amazon\", \"Target\", \"FedEx\").",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobsPerCompany": {
                        "title": "Jobs per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs to return per company (1–1000).",
                        "default": 25
                    },
                    "enableScrapeByUrl": {
                        "title": "Job links",
                        "type": "boolean",
                        "description": "Collect structured data from individual Indeed job page links.",
                        "default": false
                    },
                    "jobUrls": {
                        "title": "Job URLs",
                        "type": "array",
                        "description": "Indeed job page URLs you want to collect.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchJobDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "Include each job's full description, benefits, and applicant count. Slightly slower but much richer.",
                        "default": true
                    },
                    "includeRaw": {
                        "title": "Include extended data",
                        "type": "boolean",
                        "description": "Attach extended record data under the raw field. Larger output.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Optional. Every record is always saved to the run's dataset — this webhook is an additional real-time push. When set, each new record is also sent to this URL (CRM, Slack, Zapier, Make, Google Sheets).",
                        "default": ""
                    },
                    "webhookFormat": {
                        "title": "Webhook format",
                        "enum": [
                            "json",
                            "slack"
                        ],
                        "type": "string",
                        "description": "json = full record object; slack = Slack-friendly message payload.",
                        "default": "json"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Target country market (e.g. us, uk, ca, au, de, fr).",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total job records across all enabled modes.",
                        "default": 10000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy settings",
                        "type": "object",
                        "description": "Residential US proxy recommended for best results and consistent throughput.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
