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

Scrape Indeed job listings with titles, companies, salaries, locations, and full descriptions. Track hiring trends, monitor competitor job postings, and build job board aggregators.

- **URL**: https://apify.com/fatihai-tools/indeed-jobs-scraper.md
- **Developed by:** [fatih dağüstü](https://apify.com/fatihai-tools) (community)
- **Categories:** Jobs
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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, Salary & Company Data | $2/1K

Scrape job listings from Indeed.com at scale. The fastest **Indeed scraper** and **job listing scraper** to extract job titles, salaries, company names, locations, job types, and full descriptions — **no login required**, no API keys needed.

Used by HR teams to monitor job markets, recruiters to source candidates, salary researchers, and job aggregator platforms.

### Why Use This Indeed Jobs Scraper?

- **Any Job Search** — Search by keyword and location, just like Indeed's own search box
- **Full Job Data** — Title, company, location, salary, job type, description, posted date, benefits
- **Salary Extraction** — Parses "$60,000 - $80,000 a year" and "$25 - $35 an hour" into structured numbers
- **Remote Detection** — Automatically flags remote-friendly and work-from-home positions
- **Multi-Query Support** — Run multiple searches in a single actor run (e.g. "data analyst", "data scientist")
- **Job Type Filter** — Full-time, part-time, contract, temporary, internship
- **Date Posted Filter** — Last 24 hours, 3 days, 7 days, or 14 days
- **Salary Filter** — Skip listings below a minimum annual salary
- **Pay Per Result** — $2 per 1,000 jobs found, no subscription required

### What Data Do You Get?

| Field | Description | Example |
|-------|-------------|---------|
| `jobTitle` | Job title | Senior Software Engineer |
| `company` | Company name | Google |
| `location` | Job location | Mountain View, CA |
| `salaryText` | Raw salary text | $150,000 - $200,000 a year |
| `salaryMin` | Minimum salary (annualized) | 150000 |
| `salaryMax` | Maximum salary (annualized) | 200000 |
| `salaryType` | Pay frequency | yearly |
| `jobType` | Employment type | Full-time |
| `description` | Job description (first 500 chars) | We are looking for a... |
| `postedDate` | When posted | 2 days ago |
| `validThrough` | Expiry date (ISO 8601) | 2026-04-15T00:00:00Z |
| `isRemote` | Remote work available | true |
| `benefits` | Listed benefits | ["401(k)", "Health insurance"] |
| `jobUrl` | Direct link to the job | https://www.indeed.com/viewjob?jk=... |
| `searchQuery` | The query that found this job | software engineer |
| `searchLocation` | The location searched | New York |
| `scrapedAt` | Timestamp | 2026-03-04T12:00:00.000Z |

### How to Use

#### Find Software Engineering Jobs in New York

```json
{
    "searchQueries": ["software engineer", "backend developer"],
    "location": "New York, NY",
    "maxResults": 200,
    "jobType": "fulltime"
}
````

#### Find Remote Marketing Jobs Posted This Week

```json
{
    "searchQueries": ["marketing manager", "digital marketing"],
    "location": "Remote",
    "maxResults": 100,
    "datePosted": "7",
    "jobType": "all"
}
```

#### High-Salary Data Science Roles

```json
{
    "searchQueries": ["data scientist", "machine learning engineer", "AI researcher"],
    "location": "San Francisco, CA",
    "maxResults": 150,
    "salaryMin": 120000,
    "jobType": "fulltime"
}
```

#### Contract and Freelance Opportunities

```json
{
    "searchQueries": ["python developer", "react developer"],
    "location": "",
    "maxResults": 300,
    "jobType": "contract",
    "datePosted": "3"
}
```

#### Nationwide Job Market Research

```json
{
    "searchQueries": ["nurse", "teacher", "truck driver", "accountant"],
    "location": "",
    "maxResults": 500
}
```

### Pricing

**$2 per 1,000 job listings** — Pay only for what you scrape.

| Jobs Scraped | Cost |
|-------------|------|
| 100 | $0.20 |
| 1,000 | $2.00 |
| 5,000 | $10.00 |
| 10,000 | $20.00 |

No monthly subscription. No wasted credits. Stop anytime.

### Indeed Scraper vs Competitors

| Feature | This Actor | Competitor A | Competitor B |
|---------|-----------|--------------|--------------|
| Price | **$2/1K** | $5/1K | $10/1K |
| Salary Parsing | **Structured** | Raw text only | None |
| Multi-query | **Yes** | No | Yes |
| Job Type Filter | **Yes** | Partial | Yes |
| Date Filter | **Yes** | Yes | No |
| Salary Filter | **Yes** | No | No |
| Benefits Data | **Yes** | No | No |
| Full Description | **Yes** | Partial | Yes |

### Frequently Asked Questions

#### Is it legal to scrape Indeed?

Indeed job listings are **publicly accessible** without login. Scraping public web data for research, market analysis, and aggregation is a common and widely accepted practice. You are not circumventing any authentication or accessing private data. Always comply with Indeed's Terms of Service and applicable laws in your jurisdiction.

#### How many jobs can I scrape?

Each search can return up to 1,000 results per query. Run multiple queries to cover more roles. Indeed typically indexes millions of active listings.

#### Does the scraper get blocked?

The actor uses residential proxies and human-like browsing patterns (random delays, realistic headers, user agent rotation) to minimize blocking. If you encounter blocks, ensure you have residential proxy enabled in settings.

#### Can I get jobs from a specific city or country?

Yes — set `location` to any city, state, country, or postal code. Set it to "Remote" for remote-only jobs.

#### How fresh is the data?

Every run fetches live data directly from Indeed. Use the `datePosted` filter to get only the freshest listings (e.g., last 24 hours).

#### What does "salaryMin" represent for hourly jobs?

Hourly salaries are automatically annualized (multiplied by 2,080 hours/year) so you can compare all jobs consistently. The `salaryType` field tells you the original pay frequency.

#### Can I monitor new job postings automatically?

Yes — use Apify's scheduling feature to run this actor on a schedule (e.g., daily) and only fetch jobs posted in the last 24 hours using `"datePosted": "1"`. Combine with Apify's dataset deduplication to track only new listings.

### Related Actors by intelligent\_yaffle

Looking for more data? Check out these actors from the same author:

- **[LinkedIn Jobs Scraper](https://apify.com/intelligent_yaffle/linkedin-jobs-scraper)** — Scrape LinkedIn job postings with company details and applicant counts
- **[LinkedIn Company Scraper](https://apify.com/intelligent_yaffle/linkedin-company-scraper)** — Get company data: size, industry, description, and employee count
- **[LinkedIn Company Employees](https://apify.com/intelligent_yaffle/linkedin-company-employees)** — Find employees at any company, filter by job title
- **[Google Maps Email Extractor](https://apify.com/intelligent_yaffle/google-maps-email-extractor)** — Extract business emails from Google Maps listings
- **[Contact Email Finder](https://apify.com/intelligent_yaffle/contact-email-finder)** — Find contact emails from any list of websites
- **[G2 Reviews Scraper](https://apify.com/intelligent_yaffle/g2-reviews-scraper)** — Scrape software reviews and ratings from G2.com
- **[GitHub Trending Scraper](https://apify.com/intelligent_yaffle/github-trending-scraper)** — Track trending repositories and developers on GitHub

### Use Cases

- **Job Market Research** — Analyze demand for specific skills, track salary trends by location and role
- **Salary Benchmarking** — Gather salary data to benchmark your compensation offers
- **Recruitment Intelligence** — Monitor which companies are hiring for specific roles
- **Job Board Aggregation** — Build your own job board powered by Indeed data
- **Competitive Talent Analysis** — See which competitors are hiring and for what positions
- **HR Analytics** — Study job description patterns, required skills, and benefit trends
- **Career Research** — Understand what qualifications employers actually require

### Technical Notes

- **Pagination:** Each Indeed search page shows ~15 results. The actor paginates automatically using `start=0, 10, 20...`
- **Detail pages:** For each listing, the actor visits the individual job URL to extract the full description and structured data
- **Rate limiting:** Random delays of 2-6 seconds between requests prevent overwhelming Indeed's servers
- **Proxy:** Residential proxy is strongly recommended for production use
- **Anti-bot:** The actor rotates user agents and uses human-like request headers

# Actor input Schema

## `searchQueries` (type: `array`):

List of job search keywords (e.g. 'software engineer', 'marketing manager', 'data analyst'). Each query will be scraped separately.

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

City, state, or country to search in (e.g. 'New York', 'Remote', 'San Francisco, CA'). Leave empty for all locations.

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

Maximum number of job listings to scrape per search query.

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

Filter by employment type.

## `datePosted` (type: `string`):

Filter by how recently the job was posted.

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

Only include jobs with a listed salary of at least this amount per year. Set to 0 to include all jobs (including those without salary info).

## `proxy` (type: `object`):

Proxy settings for bypassing Indeed's anti-bot protection. Residential proxies are recommended.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer",
    "data analyst"
  ],
  "location": "",
  "maxResults": 100,
  "jobType": "all",
  "datePosted": "all",
  "salaryMin": 0
}
```

# 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 = {
    "searchQueries": [
        "software engineer",
        "data analyst"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihai-tools/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 = { "searchQueries": [
        "software engineer",
        "data analyst",
    ] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fatihai-tools/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 with titles, companies, salaries, locations, and full descriptions. Track hiring trends, monitor competitor job postings, and build job board aggregators.",
        "version": "1.0",
        "x-build-id": "jKQmHgGyLxPzXOp3y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fatihai-tools~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fatihai-tools-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/fatihai-tools~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fatihai-tools-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/fatihai-tools~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fatihai-tools-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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of job search keywords (e.g. 'software engineer', 'marketing manager', 'data analyst'). Each query will be scraped separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, or country to search in (e.g. 'New York', 'Remote', 'San Francisco, CA'). Leave empty for all locations.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results Per Query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape per search query.",
                        "default": 100
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "all",
                            "fulltime",
                            "parttime",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by employment type.",
                        "default": "all"
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "all",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Filter by how recently the job was posted.",
                        "default": "all"
                    },
                    "salaryMin": {
                        "title": "Minimum Annual Salary (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include jobs with a listed salary of at least this amount per year. Set to 0 to include all jobs (including those without salary info).",
                        "default": 0
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for bypassing Indeed's anti-bot protection. Residential proxies are recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
