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

Scrape Indeed job listings by keyword and location: title, company, location, salary, job type and a direct apply link. A stealth anti-bot browser over residential proxies passes Cloudflare reliably. No login or API key required.

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

## Pricing

from $5.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

Extract **job listings from Indeed** by keyword and location — title, company, location, salary, job type and a direct apply link — as clean structured data. This **Indeed scraper** runs a stealth, anti-bot browser over residential proxies, so it reliably gets past Indeed's Cloudflare protection where plain HTTP scrapers fail. No login, no API key, no captcha solving on your side.

Built for recruiters, job boards, market-research teams and data engineers who need **fresh Indeed job data** at scale. Feed it a list of positions and locations, pick a country, and get a tidy dataset you can export to JSON, CSV or Excel, or pull straight from the Apify API.

### What data you can extract

| Field | Type | Description |
|---|---|---|
| `position` | string | The search keyword this job matched |
| `searchLocation` | string | The search location |
| `country` | string | Indeed country domain searched |
| `jobKey` | string | Indeed's unique job id |
| `title` | string | Job title |
| `company` | string | Hiring company |
| `location` | string | Job location (city, state, ZIP or "Remote/Hybrid") |
| `isRemote` | boolean | Whether the role is remote/hybrid |
| `salary` | string | Salary range as shown on Indeed |
| `url` | string | Direct link to the job posting |
| `scrapedAt` | string | ISO 8601 extraction timestamp |

### How to use

1. Click **Try for free**.
2. In **Positions / keywords**, add one or more job titles (e.g. `software developer`, `registered nurse`).
3. In **Locations**, add cities or `Remote` (leave empty for a nationwide search).
4. Pick a **Country** and set **Max jobs per search**.
5. Click **Start** and download the results as JSON, CSV or Excel — or fetch them via the Apify API.

### Pricing

This actor uses **pay-per-result** pricing: you only pay for the jobs you successfully extract — no monthly subscription and no Indeed API key required. The platform's free tier is enough to test it end to end.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `positions` | array | — (required) | Job titles or keywords to search |
| `locations` | array | `["New York, NY"]` | Cities, regions or `Remote`. Empty = nationwide |
| `country` | string | `US` | Indeed regional domain (US, UK, CA, AU, IE, IN, SG, ZA, NZ) |
| `maxItemsPerSearch` | integer | `50` | Target jobs per position × location |
| `proxyConfiguration` | object | Residential | Residential proxies are required for Indeed |

### Output example

```json
{
  "position": "software developer",
  "searchLocation": "New York, NY",
  "country": "US",
  "jobKey": "4fe67022ddd7987e",
  "title": "Sr. Software Development Engineer",
  "company": "Amazon.com Services LLC",
  "location": "New York, NY 10261",
  "isRemote": false,
  "salary": "$184,900 - $250,200 a year",
  "url": "https://www.indeed.com/viewjob?jk=4fe67022ddd7987e",
  "scrapedAt": "2026-06-11T00:00:00.000Z"
}
````

### How it reaches more jobs

Indeed gates deep pagination behind a login wall. Instead of paginating, this actor **partitions each search by date posted** (last 1, 3, 7 and 14 days) — each partition returns a fresh page of recent jobs — and deduplicates by job id. Every request uses a fresh residential IP with automatic retries, so transient Cloudflare challenges are retried rather than failing your run.

### Other actors you may like

- **[LinkedIn Jobs Scraper](https://apify.com/sheshinmcfly/linkedin-jobs-scraper)** — job listings from LinkedIn.
- **[Trustpilot Reviews Scraper](https://apify.com/sheshinmcfly/trustpilot-reviews-scraper)** — company reviews and ratings.
- **[Google Maps Scraper](https://apify.com/sheshinmcfly/google-maps-scraper)** — local business data.
- **[USPTO Trademark Checker](https://apify.com/sheshinmcfly/uspto-trademark-checker)** — trademark search and status.

### FAQ

**Do I need an Indeed account or API key?** No. The actor requires no login or API key.

**Which countries are supported?** United States, United Kingdom, Canada, Australia, Ireland, India, Singapore, South Africa and New Zealand.

**Why are residential proxies required?** Indeed blocks datacenter IPs via Cloudflare. Residential proxies plus the stealth browser are what make extraction reliable.

**How many jobs can I get per search?** Each position × location returns recent jobs partitioned by date; raise *Max jobs per search* and add more positions/locations to scale.

**Are the results deduplicated?** Yes — jobs are deduplicated by Indeed's job id across all date partitions.

### Legal disclaimer

This actor extracts **publicly available job-posting data** that Indeed shows to any visitor without logging in. It does not access private, authenticated or personal data. Use the extracted data in compliance with Indeed's terms and applicable law (including Chile's Ley 19.628 on data protection). You are responsible for how you use the data; this tool is intended for research, recruiting and lawful business use.

### Version history

- **0.2** — Rebuilt on a stealth anti-CDP browser (Patchright) over residential proxies for reliable Cloudflare bypass; date-partitioned search with per-request IP rotation and retries.

***

**Keywords:** indeed scraper, indeed jobs scraper, job listings scraper, indeed api, job data extraction, recruitment data, job board scraper, indeed salary data, hiring data, jobs dataset, employment data scraper.

# Actor input Schema

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

Job titles or keywords to search, e.g. software developer, registered nurse. Each runs against each location.

## `locations` (type: `array`):

Cities, regions or 'Remote' to search. Leave empty for a nationwide search.

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

Indeed regional domain to search.

## `maxItemsPerSearch` (type: `integer`):

Target jobs per position × location. The actor partitions by date to reach it without deep pagination (which Indeed gates behind login).

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

RESIDENTIAL proxies are required — Indeed blocks datacenter IPs via Cloudflare. Do not change unless testing.

## Actor input object example

```json
{
  "positions": [
    "software developer",
    "data analyst"
  ],
  "locations": [
    "New York, NY",
    "Remote"
  ],
  "country": "US",
  "maxItemsPerSearch": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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": [
        "software developer"
    ],
    "locations": [
        "New York, NY"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sheshinmcfly/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": ["software developer"],
    "locations": ["New York, NY"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("sheshinmcfly/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": [
    "software developer"
  ],
  "locations": [
    "New York, NY"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call sheshinmcfly/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper",
        "description": "Scrape Indeed job listings by keyword and location: title, company, location, salary, job type and a direct apply link. A stealth anti-bot browser over residential proxies passes Cloudflare reliably. No login or API key required.",
        "version": "0.2",
        "x-build-id": "GBoQQUSypyjdcY5Th"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sheshinmcfly~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sheshinmcfly-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/sheshinmcfly~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sheshinmcfly-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/sheshinmcfly~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sheshinmcfly-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": [
                    "positions"
                ],
                "properties": {
                    "positions": {
                        "title": "Positions / keywords",
                        "type": "array",
                        "description": "Job titles or keywords to search, e.g. software developer, registered nurse. Each runs against each location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions or 'Remote' to search. Leave empty for a nationwide search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "UK",
                            "CA",
                            "AU",
                            "IE",
                            "IN",
                            "SG",
                            "ZA",
                            "NZ"
                        ],
                        "type": "string",
                        "description": "Indeed regional domain to search.",
                        "default": "US"
                    },
                    "maxItemsPerSearch": {
                        "title": "Max jobs per search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Target jobs per position × location. The actor partitions by date to reach it without deep pagination (which Indeed gates behind login).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "RESIDENTIAL proxies are required — Indeed blocks datacenter IPs via Cloudflare. Do not change unless testing.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
