# Indeed Jobs Scraper — Date & Company Filters, No API Key (`datascoutlab/indeed-scraper`) Actor

Scrape Indeed job listings reliably: title, company, salary, location, rating, posting date. Filter by how recently posted, exclude companies and keywords, get accurate per-country results. No API key

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

## Pricing

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Indeed Jobs Scraper — Date & Company Filters, Full Descriptions

Scrape Indeed job listings **reliably**, with the filters the other scrapers don't give you. Enter a job title and location and get back every listing — position, company, salary, location, company rating, posting date and the **full job description** — filtered by how recently posted, with companies and keywords you don't want excluded. **No API key, no login.**

Built to fix the two things that make other Indeed scrapers frustrating: they break silently, and they ignore the filters people actually ask for. This one retries through rotating sessions until it gets real data, and lets you filter by recency, exclude employers, and pin the exact country.

| You give it | You get back |
| --- | --- |
| A job title (`registered nurse`, `data analyst`) | Every matching Indeed listing, one row each |
| A location + country | Results from the correct country storefront — no wrong-country mixups |
| `postedWithinDays` | Only jobs posted that recently — fresh leads, not stale ones |
| `excludeCompanies` / `excludeKeywords` | Those employers and titles filtered out — you don't pay for noise |

### What does the Indeed Jobs Scraper do?

Give it one or more search terms and a location, and it reads Indeed's job listings for the correct country, paginates through the results, and returns each job as a clean JSON row: position, company, salary, location, company rating and review count, job type, posting date, remote flag, and the full description from the job's detail page. It enforces the country by using Indeed's own country domain, so a UK search never returns US jobs. No Indeed account, no API key.

### Who is it for?

| Audience | What they pull |
| --- | --- |
| **Recruiters & sourcers** | Fresh, filtered candidate-side listings without agency-spam employers |
| **Job boards & aggregators** | Structured listings to populate or benchmark their own board |
| **Market & salary researchers** | Salary ranges, hiring volume and role trends by location |
| **Sales teams** | Companies actively hiring (a buying-intent signal) for a given skill |
| **Data & AI teams** | Clean job rows with full descriptions for NLP and labor-market models |

### Why use this scraper?

- **Reliable, not silently broken.** Rotating-session retries mean the run delivers data or fails loudly — not the empty results and "billed for nothing" that plague other Indeed scrapers.
- **Recency filter.** `postedWithinDays` returns only fresh postings — a filter competitors were asked for and didn't add.
- **Exclude employers & keywords.** Drop staffing agencies or junior/senior titles you don't want — and you're not billed for filtered-out jobs.
- **Correct country, every time.** Country is enforced by storefront domain, so results match the country you asked for.
- **Full job descriptions included.** The complete description text and HTML from each job's detail page — not just a snippet.

### What data can you extract from Indeed?

Each job is one row:

```json
{
    "searchTerm": "registered nurse",
    "country": "us",
    "jobkey": "cf4db6eeb4d7d47d",
    "position": "Registered Nurse (RN) — ICU",
    "company": "Baylor Scott & White Health",
    "companyRating": 3.8,
    "companyReviewCount": 1204,
    "location": "Dallas, TX",
    "salary": "$75,000 - $98,000 a year",
    "jobType": "Full-time",
    "remote": false,
    "postedAt": "2 days ago",
    "isNew": true,
    "isUrgentlyHiring": true,
    "snippet": "ICU RN needed for a 350-bed facility…",
    "description": "Full role description, responsibilities, requirements and benefits…",
    "url": "https://www.indeed.com/viewjob?jk=cf4db6eeb4d7d47d"
}
````

| Field | Description |
| --- | --- |
| `position` / `company` | Job title and employer |
| `salary` | Salary range where Indeed shows it |
| `location` / `remote` | Location and remote flag |
| `companyRating` / `companyReviewCount` | Employer's Indeed rating and review count |
| `jobType` | Full-time, part-time, contract, etc. |
| `postedAt` / `isNew` / `isUrgentlyHiring` | Recency and hiring-urgency signals |
| `snippet` / `description` / `descriptionHtml` | Search snippet + full job description (text and HTML) |
| `url` | Direct link to the listing |

### How to scrape Indeed jobs

1. Add search terms to **Positions** (`data analyst`, `registered nurse`).
2. Set a **location** and pick the **country**.
3. Optionally set **Posted within (days)**, **exclude companies**, and **exclude title keywords**.
4. Run the Actor and export as JSON, CSV or Excel, or pull it via the Apify API.

### How to scrape only recent Indeed job postings

Set `postedWithinDays` (e.g. `1`, `3`, `7`) and the scraper returns only jobs posted within that window — ideal for recruiters and job boards that need fresh leads and don't want to re-process stale listings on every run. Combine it with a scheduled daily run to build a rolling feed of new postings.

### How to exclude companies from Indeed search results

Add employer names to `excludeCompanies` (case-insensitive) — staffing agencies, competitors, or any company you don't want in your dataset. Matching jobs are dropped before billing, so you only pay for the listings you keep. Use `excludeKeywords` the same way to drop titles containing `senior`, `intern`, or any term.

### How much does it cost to scrape Indeed?

You pay per job returned. Filtered-out jobs (by company, keyword or recency) are not billed. Turn off `includeDescription` for a faster, cheaper overview run when you only need title/company/salary; leave it on for the full description text.

### How to export Indeed jobs to CSV or Google Sheets

Open the **Dataset** tab and export as CSV, Excel or JSON, or connect the Apify **Google Sheets integration** so each scheduled run appends fresh jobs to a living spreadsheet.

### Indeed API alternative

Indeed's public job-search API was deprecated, leaving no official way to pull listings programmatically. This Actor is the practical alternative: give it a search and location and get structured job data — salary, description, company rating, posting date — as JSON or CSV, callable from the Apify API or from AI agents via MCP.

### Input configuration

| Field | Type | Notes |
| --- | --- | --- |
| `positions` | array | Search terms / job titles |
| `location` | string | City, state or region |
| `country` | string | Storefront country (enforced by domain) |
| `maxItems` | integer | Max jobs per search (billed per job) |
| `postedWithinDays` | integer | Only jobs posted within N days |
| `excludeCompanies` | array | Employers to skip |
| `excludeKeywords` | array | Title keywords to skip |
| `includeDescription` | boolean | Fetch full description per job (default on) |

### Integrations

- **Jobs → Google Sheets** — auto-append each run's listings to a spreadsheet.
- **Jobs → Slack / Discord** — get notified when new matching jobs appear.
- **Jobs → Make / Zapier** — push jobs into an ATS, CRM, or alert workflow.
- **Jobs → BigQuery / Snowflake** — warehouse listings via Airbyte for labor-market analytics.
- **Scheduled runs & webhooks** — run daily for a fresh-jobs feed, or POST results on completion.

### Use with AI agents via MCP

Callable from AI assistants via Apify's MCP server — ask "find remote data-analyst jobs posted this week, excluding staffing agencies" and your assistant runs it and returns structured results.

### FAQ

**Why do other Indeed scrapers keep breaking?** Indeed throttles and varies its pages; scrapers that don't rotate sessions and retry return empty results. This Actor retries on fresh sessions until it gets real data.

**Can I get the full job description?** Yes — `includeDescription` (on by default) fetches the complete description text and HTML from each job's detail page.

**Do I need an Indeed account or API key?** No. No login, no key.

### Disclaimer

This Actor is not affiliated with, endorsed by, or sponsored by Indeed. "Indeed" is a trademark of Indeed, Inc. It accesses only publicly available job listings. Results may contain personal data — comply with Indeed's Terms of Service and applicable law (GDPR, CCPA); do not scrape personal data without a legitimate basis.

### SEO Keywords

indeed scraper, indeed jobs scraper, scrape indeed, indeed api alternative, indeed job listings, job scraper, jobs data extraction, indeed salary data, recruitment data scraper, job board scraper, indeed csv export, indeed json, labor market data, hiring data scraper, indeed jobs by location, apify indeed actor

# Actor input Schema

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

Job titles or keywords to search, e.g. `data analyst`, `registered nurse`. One per line.

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

City, state or region, e.g. `Austin, TX`. Leave empty for nationwide.

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

Indeed storefront — results are enforced by country domain (fixes wrong-country results).

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

Cap jobs collected per search term. You are billed per job.

## `postedWithinDays` (type: `integer`):

Only jobs posted within this many days (e.g. 1, 3, 7, 14). Leave empty for all.

## `excludeCompanies` (type: `array`):

Skip jobs from these companies (case-insensitive substring), e.g. staffing agencies you don't want.

## `excludeKeywords` (type: `array`):

Skip jobs whose title contains any of these, e.g. `senior`, `intern`.

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

Fetch each job's full description from its detail page. Slower (detail pages are heavily protected); off by default for fast, reliable overview rows.

## Actor input object example

```json
{
  "positions": [
    "data analyst"
  ],
  "location": "",
  "country": "us",
  "maxItems": 100,
  "includeDescription": false
}
```

# Actor output Schema

## `results` (type: `string`):

Job postings with company, location, salary and posting date.

## `resultsCsv` (type: `string`):

The same rows as CSV — open in Excel or pull into Google Sheets with IMPORTDATA().

# 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": [
        "data analyst"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutlab/indeed-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": ["data analyst"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper — Date & Company Filters, No API Key",
        "description": "Scrape Indeed job listings reliably: title, company, salary, location, rating, posting date. Filter by how recently posted, exclude companies and keywords, get accurate per-country results. No API key",
        "version": "0.1",
        "x-build-id": "zZjzAV0Oae4UJVmL2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutlab~indeed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutlab-indeed-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/datascoutlab~indeed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascoutlab-indeed-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/datascoutlab~indeed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutlab-indeed-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. `data analyst`, `registered nurse`. One per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state or region, e.g. `Austin, TX`. Leave empty for nationwide.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "in",
                            "nl",
                            "ie",
                            "es",
                            "it",
                            "br",
                            "mx",
                            "sg",
                            "za"
                        ],
                        "type": "string",
                        "description": "Indeed storefront — results are enforced by country domain (fixes wrong-country results).",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max jobs per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Cap jobs collected per search term. You are billed per job.",
                        "default": 100
                    },
                    "postedWithinDays": {
                        "title": "Posted within (days)",
                        "type": "integer",
                        "description": "Only jobs posted within this many days (e.g. 1, 3, 7, 14). Leave empty for all."
                    },
                    "excludeCompanies": {
                        "title": "Exclude companies",
                        "type": "array",
                        "description": "Skip jobs from these companies (case-insensitive substring), e.g. staffing agencies you don't want.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude title keywords",
                        "type": "array",
                        "description": "Skip jobs whose title contains any of these, e.g. `senior`, `intern`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "Fetch each job's full description from its detail page. Slower (detail pages are heavily protected); off by default for fast, reliable overview rows.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```