# Indeed Scraper — Jobs, Salaries & Companies (`innolabs/indeed-scraper`) Actor

Indeed scraper API: job listings from Indeed in 60+ countries with full descriptions, salaries, job types, remote flag, company ratings and employer details. JSON/CSV/Excel.

- **URL**: https://apify.com/innolabs/indeed-scraper.md
- **Developed by:** [Tristan Leroux](https://apify.com/innolabs) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Indeed Scraper

Scrape **Indeed jobs in 62 countries** — www.indeed.com, uk.indeed.com, de.indeed.com,
ca.indeed.com, in.indeed.com and every other Indeed site. Search by job title and location
with the same filters as the website (date posted, job type, remote/hybrid, experience
level, distance, minimum salary, sort by date), or paste Indeed search, company and job URLs.
Every job comes with the **full description**, **salary** (min, max, currency, period),
job types, remote flag, exact location with coordinates, posting date, apply URL and
**company details** (rating, reviews, industry, size, revenue, website, logo). No login,
no API key. Export as JSON, CSV or Excel, or pull the data through the API.

### What does Indeed Scraper do?

Indeed Scraper reads Indeed's job search and returns one clean row per job:

- **Positions × locations** — type several job titles or keywords (`software engineer`,
  `nurse`) and several locations (`New York, NY`, `Austin, TX`); every combination is
  searched. Indeed's operators work too: `company:(Google)`, `title:(data engineer)`,
  `python -java`.
- **62 countries** — pick the Indeed site with **Country**; distances are in miles in the
  US and UK and in kilometres elsewhere, as on Indeed.
- **Website filters** — date posted (24 hours, 3, 7 or 14 days), job type (full-time,
  part-time, contract, internship, temporary, permanent and more), remote or hybrid,
  experience level, distance from the location, minimum salary and sort by date or relevance.
- **Indeed URLs** — paste search result pages (filters in the URL such as `fromage`, `jt`,
  `sc`, `radius`, `sort` and `salaryType` are kept), company pages
  (`/cmp/<company>/jobs`) or individual job pages (`/viewjob?jk=…`) from any Indeed site.
- **Up to about 1,000 jobs per search** — Indeed's own limit; the scraper pages through
  all of them (100 jobs per request).
- **Full job data in every row** — description as text and HTML, salary, job types,
  remote/hybrid flags, experience level, skills and benefits Indeed tagged, occupations,
  posting date, apply URL on the employer's site, urgent-hire flag, and the company's
  rating, review count, industry, employees, revenue, CEO, website, address and logo.
- **No duplicates** — a job found by several searches is delivered and charged once.

### Use cases

- **Recruiters and staffing agencies** — find companies hiring for the roles you place,
  with the hiring company's website, size and industry for outreach.
- **Lead generation and sales** — build lists of employers that are actively hiring
  (urgent hires, high-volume hiring) in a city, industry or country.
- **Salary benchmarking** — collect pay ranges with currency and period for a job title
  across cities and countries.
- **Labour-market research** — track demand for skills, job types, remote work and
  posting volume over time.
- **Job boards and aggregators** — feed fresh postings with full descriptions and apply
  links into your own site or alerts (use "Date posted: last 24 hours" on a schedule).
- **Data and AI teams** — descriptions, skills and occupations ready for classification,
  matching or LLM pipelines.

### How much does it cost?

You pay only for the jobs you get (pay-per-event). Duplicates and jobs over your limits are
never charged. Full descriptions and company details are included in the price.

| Event | What you pay for | Free plan | Paid plans (from) |
| --- | --- | --- | --- |
| `job` | One Indeed job in the dataset, with description, salary and company details | $0.045 per 1,000 | $0.036 per 1,000 |

"Paid plans (from)" is the Gold-and-above price; Bronze ($0.042) and Silver ($0.039) sit in
between. Apify also charges a tiny actor-start fee ($0.00005 per run).

Worked examples (Free plan prices):

1. **Salary benchmark** — 5 job titles × 4 cities × 100 jobs = 2,000 jobs × $0.045 / 1,000 =
   **$0.09** ($0.072 on Gold and above).
2. **Daily new-jobs feed** — 10 searches with "last 24 hours", about 150 new jobs each, every
   day for 30 days = 45,000 jobs × $0.045 / 1,000 = **$2.025** ($1.62 on Gold and above).

The Apify Free plan includes $5 monthly credit, enough for about 111,000 jobs every month.

### How to use Indeed Scraper

In Apify Console:

1. Open Indeed Scraper and click **Try for free**.
2. Enter job titles or keywords in **Positions** (prefilled with `software engineer`) and
   cities or regions in **Locations** (prefilled with `New York, NY`), and pick the
   **Country**. Or paste Indeed URLs into **Indeed URLs**.
3. Set **Max jobs per search** and, if you like, the filters: date posted, job type, remote,
   experience level, distance, minimum salary and sort order.
4. Click **Start**, then open the **Output** tab (views: Jobs, Salaries, Companies) and export
   the dataset as JSON, CSV, Excel or HTML.

Through the API:

1. Get your API token in Apify Console → Settings → Integrations.
2. Call the actor with your input JSON (see [Integrations and API](#integrations-and-api)).
3. Read the dataset items from the run.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `positions` | array | – | Job titles or keywords; Indeed operators such as `company:(Google)` work. |
| `locations` | array | – | Cities, regions or postcodes. Empty = whole country. Every position is searched in every location. |
| `country` | string | `US` | Indeed site: `US`, `GB`, `CA`, `AU`, `IN`, `DE`, `FR`, `NL`, `ES`, `IT`, `BR`, `MX`, `JP`, `SG`, `AE` … (62 countries). |
| `startUrls` | array | – | Indeed search URLs (filters kept), company URLs (`/cmp/<name>/jobs`) or job URLs (`/viewjob?jk=…`), any Indeed site. |
| `maxItemsPerQuery` | integer | `100` | Jobs per search / search URL / company URL (Indeed shows up to ~1,000). |
| `datePosted` | string | any | `1`, `3`, `7` or `14` days. |
| `jobType` | string | any | `fulltime`, `parttime`, `contract`, `internship`, `temporary`, `permanent`, `seasonal`, `freelance`, `apprenticeship`, `perdiem`, `volunteer`, `fixedterm`, `casual`. |
| `remote` | string | any | `remote` or `hybrid`. |
| `experienceLevel` | string | any | `entry_level`, `mid_level`, `senior_level`, `no_experience`. |
| `radius` | string | `25` | Distance from each location: `0` (exact), `5`, `10`, `15`, `25`, `35`, `50`, `100` (miles in US/UK, km elsewhere). |
| `salary` | string | – | Minimum pay as written on Indeed, e.g. `$100,000`, `£50,000`, `$40 an hour`. |
| `sortBy` | string | `relevance` | `relevance` or `date`. |
| `includeDescription` | boolean | `true` | Add the full description (text + HTML). |
| `maxItems` | integer | `1000` | Hard cap on jobs for the whole run. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings. |
| `debug` | boolean | `false` | Log every request. |

Example — remote full-time data engineers posted in the last 3 days, two countries' worth
of searches via URLs:

```json
{
    "positions": ["data engineer"],
    "remote": "remote",
    "jobType": "fulltime",
    "datePosted": "3",
    "maxItemsPerQuery": 200,
    "startUrls": [
        "https://uk.indeed.com/jobs?q=data+engineer&l=London&fromage=3",
        "https://www.indeed.com/cmp/Google/jobs"
    ]
}
```

Example — nurses in Berlin within 10 km, newest first:

```json
{
    "positions": ["Pflegefachkraft"],
    "locations": ["Berlin"],
    "country": "DE",
    "radius": "10",
    "sortBy": "date",
    "maxItemsPerQuery": 300
}
```

### Output

One row per job. A real example from 2026-11-07 (description, attributes shortened):

```json
{
    "jobKey": "094334eb866af588",
    "url": "https://www.indeed.com/viewjob?jk=094334eb866af588",
    "title": "Registered Nurse",
    "company": "Innovative Renal Care",
    "companyUrl": "https://www.indeed.com/cmp/Innovative-Renal-Care",
    "companyLogo": "https://d2q79iu7y748jz.cloudfront.net/s/_squarelogo/256x256/fdd7e84a7a8e87ea81f265e4cb97d01d",
    "companyRating": 3.1,
    "companyReviewCount": 356,
    "location": "Hammond, IN",
    "city": "Hammond",
    "state": "IN",
    "postalCode": null,
    "streetAddress": null,
    "country": "US",
    "latitude": 41.58337,
    "longitude": -87.50004,
    "remote": false,
    "hybrid": false,
    "jobTypes": [
        "Full-time"
    ],
    "experienceLevel": "Mid-level",
    "salary": {
        "min": 40,
        "max": 50,
        "currency": "USD",
        "period": "hour",
        "text": "$40 - $50 an hour",
        "isEstimated": false
    },
    "snippet": "Meets all applicable state/licensing requirements. Registered Nurse License in the state of practice. Current BLS/CPR certification required.",
    "descriptionText": "Job Requirements\n\nOur Registered Nurses provide high quality patient care to patients suffering from the most advanced stage of chronic kidney disease, known as…",
    "descriptionHtml": "<div><b>Job Requirements<br>\n</b><br>\n<p>Our Registered Nurses provide high quality patient care to patients suffering from the most advanced stage of chronic k…",
    "attributes": [
        "Background check",
        "CPR Certification",
        "Nursing",
        "Dialysis",
        "RN License",
        "Hourly pay",
        "Dialysis"
    ],
    "occupations": [
        "Healthcare Occupations",
        "Patient Care Nursing Occupations",
        "Nursing Occupations",
        "Registered Nurses"
    ],
    "postedAt": "2026-08-04T05:00:00Z",
    "firstSeenAt": "2026-08-04T19:53:04Z",
    "expired": false,
    "expiresAt": null,
    "isUrgentHire": false,
    "isHighVolumeHiring": false,
    "isRepost": null,
    "applyUrl": "https://careers.innovativerenal.com/us/en/job/ARJARUUSP102785EXTERNALENUS/Registered-Nurse?utm_source=indeed&utm_medium=phenom-feeds",
    "sourceName": "Innovative Renal Care",
    "refNum": "ARJARUUSP102785EXTERNALENUS",
    "language": "en",
    "companyIndustry": "Health care",
    "companyEmployees": "1,001 to 5,000",
    "companyRevenue": null,
    "companyCeo": "David Doerr",
    "companyWebsite": "https://careers.innovativerenal.com/us/en",
    "companyAddress": "1550 W McEwen Drive Suite 600 Franklin, TN 37067",
    "companyDescription": "Innovative Renal Care (IRC) is one of the largest dialysis service providers in the United States. We provide high quality patient care to patients suffering from ESRD.",
    "searchQuery": "registered nurse",
    "searchLocation": "Chicago, IL",
    "searchUrl": null,
    "page": 1,
    "position": 9,
    "scrapedAt": "2026-11-07T11:41:57Z"
}
```

Field notes:

- `jobKey` is Indeed's job ID; `url` is the job page on the Indeed site of the search
  country. `applyUrl` is the employer's own application page where Indeed has one.
- `salary` is `null` when the employer published no pay. `min`/`max` are numbers in
  `currency`; `period` is `hour`, `day`, `week`, `month` or `year`; `text` is Indeed's
  wording in the site's language (e.g. `60.000 € – 85.000 € pro Jahr` on de.indeed.com).
  "Up to £55,000" gives `min: null, max: 55000`.
- `jobTypes`, `experienceLevel` and `attributes` (skills, benefits, shifts, education) are
  the tags Indeed shows, in the site's language. `remote` / `hybrid` are `true` when Indeed
  tags the job as remote / hybrid work (or the location is "Remote").
- `postedAt` is the employer's publication date, `firstSeenAt` when the job appeared on
  Indeed (the date filter uses this one). All dates are ISO-8601 UTC.
- `companyRating` (1–5) and `companyReviewCount` come from the company's Indeed reviews;
  company size, revenue, CEO and website are filled when the company has an Indeed profile.
- `searchQuery`, `searchLocation`, `searchUrl`, `page` and `position` tell you which input
  and result position produced the row (`page`/`position` are empty for job URLs).

### Integrations and API

Run the actor and get the jobs back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/innolabs~indeed-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"positions": ["software engineer"], "locations": ["New York, NY"], "maxItemsPerQuery": 50}'
```

Python with [apify-client](https://docs.apify.com/api/client/python):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("innolabs/indeed-scraper").call(
    run_input={
        "positions": ["data analyst", "data engineer"],
        "locations": ["London", "Manchester"],
        "country": "GB",
        "datePosted": "7",
        "maxItemsPerQuery": 200,
    }
)
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["company"], job["location"], job["salary"])
```

- **Make, Zapier, n8n** — use the Apify app/node to start the actor and send new jobs to
  Google Sheets, Airtable, Slack, a CRM or email.
- **Scheduling** — schedule a daily run with "Date posted: last 24 hours" to get only fresh
  jobs every morning.
- **Webhooks** — trigger your pipeline when a run finishes.
- **AI agents (MCP)** — connect Claude, Cursor or other MCP clients through the Apify MCP
  server at https://mcp.apify.com and let your agent search Indeed jobs.

### FAQ

#### Is it legal to scrape Indeed?

The scraper only reads job postings and company information that Indeed shows to every
visitor without logging in; it does not apply to jobs or access accounts. Job postings are
published by employers to be seen. Handle any personal data (such as a CEO name) in line
with GDPR and your local laws. This actor is not affiliated with or endorsed by Indeed.

#### Which filters are supported?

All main filters of the Indeed website: date posted, job type, remote/hybrid, experience
level, distance, minimum salary and sort by date. They can be combined. You can also paste a
search URL you built on Indeed — its filters are kept. Indeed operators such as
`company:(Name)`, `title:(…)` and `-word` work inside **Positions**.

#### How many jobs can I get?

Indeed shows up to about 1,000 jobs per search (often fewer for narrow searches). To get more,
split the search: several locations, job titles, job types or shorter date ranges. There is
no limit on the number of searches per run.

#### Do I need proxies?

No setup is needed; the default Apify Proxy is included. If Indeed refuses a request, the
scraper switches to a new IP and retries automatically. The residential proxy group also
works but is not needed.

#### Can I get only new jobs?

Yes. Set **Date posted** to "Last 24 hours" and schedule the actor daily; or sort by date.
Compare runs by `jobKey` to detect jobs you have already seen.

#### Why is the salary empty for some jobs?

Indeed only shows pay when the employer published it. Coverage depends on the country and the
role: in our tests about 85 % of US jobs, 30 % of UK and 15–20 % of German jobs had a salary.

#### Are descriptions and company details really included?

Yes, every row contains the full description (text and HTML) and the company details Indeed
has, at no extra cost. Turn off **Include full job description** for smaller files.

### Limits

- Up to about 1,000 jobs per search, an Indeed limit; split large searches.
- Salary, company size, revenue and CEO are only filled where Indeed shows them.
- Tags such as job types and skills are in the language of the Indeed site
  (e.g. "Vollzeit" on de.indeed.com).
- Company reviews, interview reviews and salary pages of companies are not included.
- Expired or removed jobs given as job URLs are listed in the run's `SUMMARY` record and not
  charged.

# Changelog

This Actor's version history is a separate document: https://apify.com/innolabs/indeed-scraper/changelog.md

# Actor input Schema

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

What to search for, one per line, e.g. 'software engineer', 'nurse', 'data analyst'. Indeed's search operators work too: 'company:(Google)', 'title:(product manager)', 'python -java'. Every position is searched in every location below.

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

City, state, region or postcode, one per line, e.g. 'New York, NY', 'Austin, TX', 'London', 'Berlin', 'Remote'. Leave empty to search the whole country.

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

Indeed country site to search (www.indeed.com, uk.indeed.com, de.indeed.com …). Start URLs use the country of their own address.

## `startUrls` (type: `array`):

Optional. Indeed search result URLs (https://www.indeed.com/jobs?q=python\&l=Austin%2C+TX\&fromage=7, filters in the URL are kept), company URLs (https://www.indeed.com/cmp/Google/jobs) or job URLs (https://uk.indeed.com/viewjob?jk=d82bc175fd28e64f). Any Indeed country site.

## `maxItemsPerQuery` (type: `integer`):

Jobs to take from each position × location search, search URL or company URL. Indeed shows up to about 1,000 jobs per search.

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

Only jobs posted on Indeed within this many days. Leave empty for any time.

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

Only jobs of this type.

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

Only remote or only hybrid jobs.

## `experienceLevel` (type: `string`):

Only jobs Indeed tags with this experience level.

## `radius` (type: `string`):

Search radius around each location: miles in the United States and United Kingdom, kilometres elsewhere (as on Indeed). Leave empty for Indeed's default of 25.

## `salary` (type: `string`):

Indeed's pay filter, written as on Indeed, e.g. '$100,000', '$40 an hour', '£50,000'. Leave empty for any pay.

## `sortBy` (type: `string`):

Relevance (Indeed's default) or date (recent jobs first).

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

Add the full description as text and HTML to every job. Turn off for smaller rows when you only need titles, companies, locations and salaries.

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

Hard cap on jobs for the whole run across all searches and URLs. The run stops cleanly when reached.

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

Apify Proxy settings. The default Apify datacenter proxy works for Indeed; when Indeed refuses a request the scraper switches to a new IP automatically.

## `debug` (type: `boolean`):

Log every request with its status code and size.

## Actor input object example

```json
{
  "positions": [
    "software engineer"
  ],
  "locations": [
    "New York, NY"
  ],
  "country": "US",
  "maxItemsPerQuery": 50,
  "sortBy": "relevance",
  "includeDescription": true,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

All jobs found by the run, one JSON object per job.

# 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 engineer"
    ],
    "locations": [
        "New York, NY"
    ],
    "maxItemsPerQuery": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("innolabs/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": ["software engineer"],
    "locations": ["New York, NY"],
    "maxItemsPerQuery": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("innolabs/indeed-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 engineer"
  ],
  "locations": [
    "New York, NY"
  ],
  "maxItemsPerQuery": 50
}' |
apify call innolabs/indeed-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,innolabs/indeed-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/iyxXtnd4RyrsiHCfr/builds/ZqZkLbNyX4eFFQeAR/openapi.json
