# Indeed Jobs Scraper - Canada, US & 6 More Countries (`akhil_rajesh/indeed-jobs-scraper`) Actor

Scrape Indeed jobs in 8 countries: Canada, the US, UK, Ireland, Australia, New Zealand, India and Germany. Search a city, a region, or a whole country swept city by city. Full descriptions, pay, employer details and direct apply links. Scheduled runs can return only jobs you have not seen before.

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

## Pricing

from $0.05 / 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.
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

Scrape **job listings from Indeed** in **eight countries** — job title, company, location, pay, job type, posting date, the **full job description**, employer details and the **employer's own apply link** — as clean, structured data. Results come from Indeed's search index, not just the promoted listings on page one. One search goes about 1,000 jobs deep, and a **whole country or province is swept city by city** to go far beyond that. Scheduled runs can return **only the jobs you haven't seen before**, so you stop paying for the same listings every day, and you can **look up specific jobs** to check whether they're still open.

**Try it now:** keep the example input (software developer in Toronto) and press **Start**. It returns 100 jobs in a few seconds.

### What data can you extract from Indeed?

One row per job listing:

| Group | Fields |
|---|---|
| **Job** | `title`, `jobTypes`, `isRemote`, `remoteType`, `attributes`, `occupations`, `isUrgentHire` |
| **Pay** | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText`, `salaryIsEstimated` |
| **Description** | `description` (plain text), `descriptionHtml` |
| **Location** | `location`, `city`, `state`, `postalCode`, `country` |
| **Applying** | `applyUrl` (the employer's careers page when there is one), `easyApply` |
| **Employer** | `company`, `companyWebsite`, `companyIndustry`, `companySize`, `companyRevenue`, `companyDescription`, `companyLogo`, `companyRating`, `companyReviewCount`, `companyUrl` |
| **Timing** | `datePosted`, `dateOnIndeed`, `isExpired` |
| **Provenance** | `url`, `jobKey`, `jobSource`, `source`, `searchQuery`, `searchLocation`, `searchCountry`, `sourceUrl`, `scrapedAt` |

Pay is returned as **numbers** (`salaryMin`, `salaryMax`) with its currency and period, alongside a readable version, so you can filter and compare without parsing. `attributes` holds every tag Indeed attaches to a job — benefits, shifts, skills, education and licences included. Export to JSON, CSV, Excel or HTML, read it through the API, or schedule runs and feed the results into your own tools.

How complete is it? In a test run of 4,517 Canadian jobs (September 2026), every row had a full description and an apply link, 83% had pay, 80% had the employer's website, and 84% had an employer rating.

### How many jobs does one run return?

As many as you ask for, up to what Indeed holds for your searches:

- **One search** (a keyword in a location) returns up to about **1,000 jobs** — that's where Indeed ends its results.
- **A whole country or region goes deeper.** Leave **Location** empty, or enter a region such as `Ontario`, `TX`, `Scotland`, `Queensland` or `Bayern`, and the Actor searches it as a whole first. When Indeed cuts that search off at its ceiling, it carries on city by city — 515 cities across the eight countries, largest first — until **Max results** is reached. For `registered nurse` across Canada, that turned 993 jobs into **5,724 unique jobs** in 3 minutes.
- **Add keywords and locations** to go further still. Every keyword is searched in every location, the results are combined, and duplicates are removed by Indeed's job key.
- **Max results** is shared fairly between your searches, so one broad search can't crowd out the others. If a search runs dry, its share goes to the rest.

For example, three keywords across Toronto and Vancouver returned **4,517 unique jobs from 1,264 employers in 41 seconds**, all with full descriptions.

Pick several countries and each location goes to the site that matches it: `Toronto, ON` only searches Canada and `Sydney NSW` only Australia, while an ambiguous `London` is searched in every country you selected. So one run can cover Toronto, Manchester, Sydney and Bengaluru together.

### Which countries can you scrape?

Canada, the United States, the United Kingdom, Ireland, Australia, New Zealand, India and Germany. Pick one under **Country** and add more under **More countries**; each is searched on its own Indeed site, in its own currency.

How much of a country's data carries pay varies a lot, and it's worth knowing before you plan around it. Measured in September 2026 on a broad search:

| Usually has pay | Often has pay | Rarely has pay |
|---|---|---|
| Canada 69%, UK 51% | Australia 40%, Ireland 43%, India 25% | Germany 17%, New Zealand 9% |

Everything else — descriptions, employer details, apply links — is just as complete everywhere.

Two things to keep in mind outside Canada and the US:

- **Search in the local language.** Indeed matches your keyword as written, so `softwareentwickler` finds German jobs that `software developer` misses.
- **Write locations the way the local site does**: `Manchester`, `Sydney NSW`, `Mumbai, Maharashtra`, `München`, `Dublin`.

### How fresh are the listings?

New listings normally appear **within a few hours** of being posted in every country, so **Posted within: Last 24 hours** works for daily monitoring.

Indeed's search does have off days. During testing, new Canadian listings once ran about three days behind for several hours before catching up. If a short **Posted within** window comes back empty, widen it or run again later.

Every row carries both `datePosted` (when the employer published the job) and `dateOnIndeed` (when Indeed listed it), so you always know how old a listing is.

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

Pay-per-event, with platform usage included — there is nothing else to pay. What a job costs depends on your Apify plan:

| Your plan | Per 1,000 jobs |
|---|---|
| Free | $0.10 |
| Starter | $0.09 |
| Scale | $0.07 |
| Business and above | $0.05 |

Plus **$0.001** each time a run starts, on every plan (charged per GB of memory; the default is 512 MB, so that's one start fee per run).

| Run | Jobs returned | On Free | On Business |
|---|---|---|---|
| The example input | 100 | $0.011 | $0.006 |
| One search, as deep as it goes | about 1,000 | $0.101 | $0.051 |
| Three keywords across two cities | 4,500 | $0.451 | $0.226 |
| One keyword across all of Canada, city by city | 5,724 | $0.573 | $0.287 |

You're charged only for jobs that are delivered; searches that find nothing cost nothing beyond the start fee. With **Only jobs you haven't seen before** switched on, a repeat run charges only for listings that are new since last time, which is what makes daily monitoring affordable. To cap spending, set a maximum cost per run in the run options — the Actor stops cleanly when it reaches the limit.

### How to scrape Indeed

1. Enter a **job keyword**, such as `software developer` or `registered nurse`. Indeed needs a keyword for every search, and specific job titles work best.
2. Pick the **country**, and add **More countries** if you want several at once.
3. Enter a **location**, such as `Toronto, ON`, `Manchester` or `Sydney NSW`. For a whole region enter `Ontario`, `TX`, `Scotland`, `Queensland` or `Bayern`; for the whole country leave it empty.
4. Set **Max results**. For country- and province-wide searches this decides how deep the city-by-city sweep goes, and so what the run costs.
5. Optionally open **Advanced filters** for job type, remote or hybrid work, posting age and search radius.
6. Press **Start**, then open the **Output** tab or export the dataset.

#### Track one employer, or reuse a search you already built

Paste URLs into **Start URLs** instead of, or alongside, keyword searches:

- A **company's jobs page** — `https://www.indeed.com/cmp/Apple/jobs` — returns that employer's listings, and only theirs: Apple, not Apple Rehab or Big Apple Bagels. `https://www.indeed.com/cmp/Apple` works too, and so does the `companyUrl` from any row. Add `?q=engineer&l=Austin%2C+TX` to the URL to narrow it to a keyword or a place.

- A **search URL** copied from your browser — `https://ca.indeed.com/jobs?q=nurse&l=Toronto%2C+ON&fromage=7` — keeps its keyword, location, radius, posting age, sort order and job-type or remote filters. Filters Indeed's search can't apply here, such as experience level, are ignored and listed in the log.

- A **single job** — `https://ca.indeed.com/viewjob?jk=1a2b3c4d5e6f7890` — returns that one job.

Each row records which URL produced it in `sourceUrl`. URLs from any of the eight Indeed sites are supported.

#### Check whether saved jobs are still open

Put job URLs or the `jobKey` values from an earlier run into **Jobs to look up** (`jobKeys`). Each job comes back with its current details, and `isExpired` tells you whether it has closed. Jobs that Indeed has removed altogether are listed in the log and saved as `JOB_KEYS_NOT_FOUND` in the run's key-value store — you aren't charged for those. Lookups are fast: a few hundred jobs take a couple of seconds.

```json
{
  "jobKeys": ["1a2b3c4d5e6f7890", "https://www.indeed.com/viewjob?jk=0f9e8d7c6b5a4321"]
}
```

#### Watch for new jobs without paying twice

Turn on **Only jobs you haven't seen before** (`onlyNewJobs`) and the Actor remembers every job it has delivered. The first run collects the lot; each run after it returns only what's new and charges only for that. In testing, repeating the same search immediately returned **0 of 24 jobs and cost nothing** beyond the start fee.

```json
{
  "searchQuery": "registered nurse",
  "country": "ca",
  "location": "Toronto, ON",
  "maxResults": 1000,
  "onlyNewJobs": true
}
```

Schedule that daily and you pay for new listings only. A few details worth knowing:

- Runs that share a **History name** (`historyName`) share their memory, so use one name per thing you're monitoring and a different name to start fresh.
- Jobs are forgotten after **45 days**, so a listing that's still open after that is offered once more.
- Jobs you ask for in **Jobs to look up** are always returned, even if they're in the history — re-checking a saved job is the point of asking for it.
- **Max results** counts new jobs, so `maxResults: 1000` means a thousand jobs you haven't seen, not a thousand searched.

#### Run it from the API

```bash
curl -X POST "https://api.apify.com/v2/actors/akhil_rajesh~indeed-jobs-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "registered nurse",
    "country": "us",
    "location": "Austin, TX",
    "datePosted": "7",
    "maxResults": 200
  }'
```

#### Run it from Python

```python
from apify_client import ApifyClient  # pip install apify-client

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("akhil_rajesh/indeed-jobs-scraper").call(run_input={
    "searchQuery": "software developer",
    "extraKeywords": ["data engineer"],
    "country": "ca",
    "location": "Toronto, ON",
    "extraLocations": ["Vancouver, BC", "Calgary, AB"],
    "maxResults": 1000,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job.get("company"), job.get("salaryText"), job.get("applyUrl"))
```

Fields without a value are left out of a row, so read optional fields with `.get()`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | string | — | Job keyword, e.g. `software developer`. Needed unless you use Start URLs |
| `extraKeywords` | array | — | More keywords; each is searched in every location |
| `country` | enum | `ca` | `ca`, `us`, `gb`, `ie`, `au`, `nz`, `in`, `de` |
| `extraCountries` | array | — | More countries to search in the same run |
| `location` | string | — | A city, a US ZIP code, or `Remote`. A region, or empty for the whole country, is swept city by city |
| `extraLocations` | array | — | More locations — the simplest way to cover a region |
| `startUrls` | array | — | Indeed search URLs, company jobs pages or single job URLs to scrape directly |
| `jobKeys` | array | — | Job keys or job URLs to look up, e.g. to check whether saved jobs are still open |
| `onlyNewJobs` | boolean | `false` | Skip and don't charge for jobs earlier runs already delivered |
| `historyName` | string | `indeed-jobs-history` | Which history `onlyNewJobs` reads and writes |
| `maxResults` | integer | `100` | Stop after this many jobs (up to 20,000) |
| `fullDescriptions` | boolean | `true` | Include each job's complete description |

<details>
<summary><strong>Advanced filters</strong></summary>

| Field | Type | Description |
|---|---|---|
| `searchRadius` | integer | Distance around the location (miles in the US and UK, km elsewhere). Default 25; 0 means the exact location |
| `datePosted` | enum | Last 24 hours, 3, 7, 14 or 30 days |
| `jobType` | enum | Full-time, part-time, contract, temporary, internship / co-op, permanent, casual or seasonal |
| `workArrangement` | enum | Remote only, or hybrid only |
| `sort` | enum | Relevance or newest first |
| `proxy` | object | Proxy groups or country; Apify Proxy is used automatically anyway |
| `debug` | boolean | Verbose logging |

</details>

### Sample output

```json
{
  "jobKey": "1a2b3c4d5e6f7890",
  "url": "https://ca.indeed.com/viewjob?jk=1a2b3c4d5e6f7890",
  "title": "Senior Full Stack Developer",
  "company": "Example Technologies",
  "companyUrl": "https://ca.indeed.com/cmp/Example-Technologies",
  "companyWebsite": "https://www.example.com",
  "companyIndustry": "Information Technology",
  "companySize": "1,001 to 5,000",
  "companyRevenue": "$100M to $500M (USD)",
  "companyRating": 3.7,
  "companyReviewCount": 214,
  "location": "Toronto, ON M5V 2T6",
  "city": "Toronto",
  "state": "ON",
  "postalCode": "M5V 2T6",
  "country": "CA",
  "isRemote": false,
  "remoteType": "Hybrid work",
  "salaryMin": 110000,
  "salaryMax": 140000,
  "salaryCurrency": "CAD",
  "salaryPeriod": "YEAR",
  "salaryText": "$110,000–$140,000 a year",
  "salaryIsEstimated": false,
  "jobTypes": ["Full-time", "Permanent"],
  "attributes": ["Full-time", "Permanent", "Hybrid work", "Dental care", "Extended health care", "Bachelor's degree", "React", "Node.js"],
  "occupations": ["Full Stack Developers", "Software Development Occupations"],
  "description": "We're looking for a senior full-stack developer with architectural ambition…",
  "datePosted": "2026-09-16T14:00:00+00:00",
  "dateOnIndeed": "2026-09-16T14:05:12+00:00",
  "applyUrl": "https://careers.example.com/jobs/4821",
  "easyApply": false,
  "isUrgentHire": false,
  "isExpired": false,
  "jobSource": "Example Technologies",
  "source": "ca.indeed.com",
  "searchQuery": "software developer",
  "searchLocation": "Toronto, ON",
  "searchCountry": "CA",
  "scrapedAt": "2026-09-21T16:03:22.347Z"
}
```

`descriptionHtml`, `companyDescription` and `companyLogo` are omitted above for readability.

### Use cases

- **Job search automation**: track new postings for a role and location, and get alerted on the ones that match
- **Salary benchmarking**: compare advertised pay by title, city and employer, using numeric ranges
- **Recruiting intelligence**: see which companies are hiring, how fast, and what they offer
- **Labour market research**: compare demand, job types, pay and remote work across eight countries
- **Lead generation**: build lists of employers actively hiring in a niche, with their website, industry, size and revenue

### FAQ

#### Are these promoted listings or organic ones?

They come from Indeed's search index — the full set of matching jobs, ordered by relevance or by date — rather than from the promoted placements at the top of Indeed's web pages. That matters most in Canada, where a visitor who isn't signed in sees only promoted listings on Indeed's website.

#### Why did a short "Posted within" window return nothing?

Usually because nothing new matched. Occasionally it's Indeed: its search sometimes falls behind on new listings for a few hours — in testing, Canadian listings were once about three days behind — and then catches up. Widen the window, or run again later. `dateOnIndeed` on each row shows how fresh the results really are.

#### Why did a very broad search return almost nothing?

Indeed's search occasionally returns a broad country-wide search — `manager` across the whole United States, say — empty or nearly empty, without reporting an error, while the same keyword in a city works. The Actor checks for this: when a country- or province-wide search looks too thin, it tries the largest cities, and if they have jobs it sweeps city by city instead. A search in a single city can't be double-checked that way, so if one looks wrong, run it again.

#### Why did a city I know has jobs return nothing?

Check that the city's country is selected. `Toronto, ON` with only the United States chosen searches Toronto on **Indeed US**, which has no Toronto listings, so the run ends with zero jobs. The Actor warns you when a location clearly belongs to a country you did not pick — the warning appears in the run's status message. Add the country under **Country** or **More countries**.

#### Why did I get fewer jobs than Max results?

Your searches ran out of jobs. One city search ends at about 1,000 results, and narrower ones end sooner. To go further, add **More keywords**, or widen the location to a province, a state or the whole country, which the Actor sweeps city by city. A **location-only search** returns nothing, because Indeed needs a keyword.

#### Why doesn't a Canadian postal code work as a location?

Indeed's search doesn't resolve Canadian postal codes, so use the city — `Toronto, ON` rather than `M5V 2T6`. If a location has both, the Actor drops the postal code and searches the city. US ZIP codes work.

#### Why is salary missing on some jobs?

Many employers don't publish pay, and how often they do varies by country — see the table above, which runs from 69% in Canada to 9% in New Zealand. It varies by occupation too. `salaryIsEstimated` tells you whether the employer stated the pay or Indeed estimated it.

#### How do I monitor new jobs every day?

Turn on **Only jobs you haven't seen before** and schedule the Actor daily. It remembers what it has delivered, so each run returns and charges for new listings only — no de-duplication needed at your end, and no repeated cost for yesterday's jobs. Leave **Posted within** empty or generous: the history does the filtering, so you still catch anything Indeed listed late.

#### Can you add another country?

Indeed runs about 50 more sites and they all work through the same service, so adding one is mostly a matter of building and checking its city list. Ask through the Actor's Issues tab and say which country you need.

### Other Actors by this developer

- [Canadian Job Market Scraper - Job Bank](https://apify.com/akhil_rajesh/canadian-jobs-scraper): Canadian job postings from the Government of Canada's job board, with salary, employer, location and NOC code
- [Wellfound Jobs Scraper](https://apify.com/akhil_rajesh/wellfound-jobs-scraper): startup jobs from Wellfound (formerly AngelList Talent) with salary and equity ranges, company size and an exact Y Combinator flag
- [SEEK, JobStreet & JobsDB Jobs Scraper](https://apify.com/akhil_rajesh/seek-jobstreet-jobsdb-scraper): jobs from SEEK, JobStreet and JobsDB in Australia, New Zealand and six Asian markets, with pay as numbers, applicant counts and change tracking
- [AutoTrader.ca Scraper](https://apify.com/akhil_rajesh/autotrader-canada-scraper): Canadian vehicle listings with price, mileage, trim and dealer
- [Price Scraper for Bot-Protected Stores](https://apify.com/akhil_rajesh/bot-wall-price-scraper): live price comparison across major Canadian retailers
- [Tennis Scraper](https://apify.com/akhil_rajesh/tennis-scraper): live scores, results, match statistics, point-by-point and bookmaker odds for ATP, WTA, Challenger and ITF

### Data source

All data comes from **Indeed**, a public job board, through the same job search service that powers Indeed's own apps — one site per country, from ca.indeed.com to de.indeed.com. This Actor reads publicly available listings only, never signs in to an account, and stores nothing beyond the dataset you request.

> **Disclaimer:** This is an independent tool. It is **not affiliated with, endorsed by, or sponsored by** Indeed, Inc. or any related entity. All product and company names are the property of their respective owners.

### Limitations

- **Indeed only**: jobs posted exclusively elsewhere aren't included
- **About 1,000 jobs per search**, so use more keywords and locations for more
- **Indeed's search has off days**: new listings can lag for a few hours, and a very broad search can come back nearly empty without an error. Indeed reports no totals, so the Actor can only catch the second case for country- and province-wide searches
- **A keyword is required** for every search
- **City-by-city sweeps cover 515 cities** across the eight countries, within 25 km or 25 miles of each, plus whatever the country- or region-wide search returns; jobs well away from a listed city can be missed
- **New Zealand has no region sweep**: Indeed only reports North and South Island there, so use the country or a city
- **Start URLs are searched exactly as pasted**, without the city-by-city sweep
- **The history behind "only new jobs" lives in your account**, so it works across scheduled runs but not across different Apify accounts
- **Canadian postal codes aren't accepted** as a location; US ZIP codes are
- **No promoted-listing flag**: Indeed's search service doesn't say which jobs employers pay to promote
- **Salary and employer details** are only present when Indeed has them
- **Job descriptions** are the employer's text as published, including any formatting quirks
- If Indeed's search service is ever unavailable, the Actor falls back to Indeed's public web pages, which show one page per search; the run's status message says when that happened
- Listings change constantly, and a job can close between runs

# Changelog

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

# Actor input Schema

## `searchQuery` (type: `string`):

What to search for, e.g. 'software developer', 'registered nurse', 'warehouse associate'. Indeed needs a keyword for every search, and matches it as written, so use the language of the country you are searching.

## `extraKeywords` (type: `array`):

Extra job keywords to search as well. Every keyword is searched in every location, and the results are combined and de-duplicated.

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

Which Indeed site to search. Add more under More countries to search several in one run.

## `extraCountries` (type: `array`):

Extra Indeed sites to search as well. Every keyword and location is searched in each country you pick, except where a location clearly belongs to one of them — 'Toronto, ON' only goes to Canada, while a bare 'London' goes to every country selected.

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

City, or a region such as a province, state, county or Bundesland — e.g. 'Toronto, ON', 'Austin, TX', 'Manchester', 'Sydney NSW', 'Mumbai, Maharashtra', 'München'. Write it the way the local Indeed site does. Indeed's search doesn't accept Canadian postal codes, so use the city instead. Leave it empty for the whole country, or name a region: either way the Actor searches it as a whole first and then goes city by city when Indeed cuts the search off at about 1,000 jobs.

## `extraLocations` (type: `array`):

Extra locations to search as well; every keyword is searched in every location. With Country set to Both, you can mix Canadian and US locations here, e.g. 'Vancouver, BC' and 'Seattle, WA'.

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

Indeed pages to scrape directly, instead of or alongside keyword searches. Paste a search URL (https://ca.indeed.com/jobs?q=nurse\&l=Toronto%2C+ON) with its filters, a company's jobs page (https://www.indeed.com/cmp/Apple/jobs), or a single job (https://ca.indeed.com/viewjob?jk=...). Canadian and US Indeed URLs are supported.

## `jobKeys` (type: `array`):

Look up specific jobs directly: paste Indeed job URLs, or the 16-character jobKey values from earlier results. Each job comes back with its current details and isExpired, so this is how you check which saved jobs are still open. Jobs Indeed no longer has are listed in the log and saved as JOB\_KEYS\_NOT\_FOUND in the run's key-value store; you are not charged for them.

## `onlyNewJobs` (type: `boolean`):

Skip jobs that earlier runs already delivered, and don't charge for them. Turn this on for a scheduled run: the first run collects everything, and each run after it returns only what is new, so you stop paying for the same listings every day. Jobs you ask for by key in 'Jobs to look up' are always returned, so you can still re-check saved jobs.

## `historyName` (type: `string`):

Which history 'Only jobs you haven't seen before' reads and writes. Runs sharing a name share their memory of delivered jobs, so use one name per monitoring job and a different name to start fresh. Jobs are forgotten after 45 days.

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

Stop after this many jobs, shared fairly between your searches. One search yields up to about 1,000 jobs; a country- or province-wide search carries on city by city beyond that, so this number decides how deep the run goes and what it costs.

## `fullDescriptions` (type: `boolean`):

Recommended ON. Adds each job's complete description as plain text and as the original HTML. Turn it off for a lighter dataset; the price per job is the same either way.

## `searchRadius` (type: `integer`):

Distance around the location to include — miles in the United States and the UK, kilometres everywhere else. Defaults to 25, the same as Indeed's own search. Use 0 for the exact location only.

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

Only include jobs Indeed listed in this window. New listings normally appear within hours; if a short window comes back empty, widen it or try again later, because Indeed's search occasionally runs behind.

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

Only include jobs Indeed tags with this type.

## `workArrangement` (type: `string`):

Only include jobs Indeed tags as remote, or as hybrid work.

## `sort` (type: `string`):

Indeed's own ordering. When 'Posted within' is combined with a job type or remote filter, results always come newest first.

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

Indeed does not accept connections from Apify's servers, so every run goes through Apify Proxy — it is enabled automatically even if you leave this off. The default datacenter proxy is all this Actor needs; set this only if you want specific proxy groups or a country.

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

Verbose logging for troubleshooting.

## Actor input object example

```json
{
  "searchQuery": "software developer",
  "country": "ca",
  "location": "Toronto, ON",
  "onlyNewJobs": false,
  "historyName": "indeed-jobs-history",
  "maxResults": 100,
  "fullDescriptions": true,
  "datePosted": "",
  "jobType": "",
  "workArrangement": "",
  "sort": "relevance",
  "proxy": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

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

Job records produced by this run.

# 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 = {
    "searchQuery": "software developer",
    "country": "ca",
    "location": "Toronto, ON",
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("akhil_rajesh/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 = {
    "searchQuery": "software developer",
    "country": "ca",
    "location": "Toronto, ON",
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("akhil_rajesh/indeed-jobs-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 '{
  "searchQuery": "software developer",
  "country": "ca",
  "location": "Toronto, ON",
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call akhil_rajesh/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,akhil_rajesh/indeed-jobs-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/XKckXjHSkMpq1tLxa/builds/Wykc6bdUAnB7ykjxt/openapi.json