# Indeed Jobs MCP Server & API - 62 Countries (`akhil_rajesh/indeed-jobs-mcp-server`) Actor

Indeed jobs for AI agents: an MCP server and live API that searches Indeed's 62 country sites by keyword, city, pay and experience level, and looks jobs up by key. Answers in seconds with title, company, yearly pay, full description, employer details and the apply link.

- **URL**: https://apify.com/akhil_rajesh/indeed-jobs-mcp-server.md
- **Developed by:** [Akhil rajesh](https://apify.com/akhil_rajesh) (community)
- **Categories:** MCP servers, Jobs, AI
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

Give your AI agent **Indeed jobs on demand**. This Actor is an **MCP server** and a **live HTTP API** for Indeed's job search in **62 countries**. An agent asks for "registered nurse jobs in Toronto posted this week that pay at least $90,000" and gets the matching jobs back in seconds: title, company, location with map coordinates, pay as posted and as a **yearly figure**, job type, remote or hybrid, experience level, posting date, the employer's **apply link** and, when asked for, the **full job description**.

It runs the same code as [Indeed Jobs Scraper](https://apify.com/akhil_rajesh/indeed-jobs-scraper), with Apify Standby switched on, so it answers each request at once instead of starting a run. For thousands of jobs, whole-country sweeps, only new jobs or Slack and Telegram alerts on a schedule, use that Actor.

### Connect your agent

Authenticate with your **Apify API token** (Apify Console → Settings → API & Integrations).

**MCP server** (Streamable HTTP): `https://akhil-rajesh--indeed-jobs-mcp-server.apify.actor/mcp`

```json
{"mcpServers": {"indeed-jobs": {"type": "http", "url": "https://akhil-rajesh--indeed-jobs-mcp-server.apify.actor/mcp",
  "headers": {"Authorization": "Bearer <YOUR_APIFY_TOKEN>"}}}}
```

In Claude Code:

```bash
claude mcp add --transport http indeed-jobs https://akhil-rajesh--indeed-jobs-mcp-server.apify.actor/mcp --header "Authorization: Bearer <YOUR_APIFY_TOKEN>"
```

A client that can't send headers can use `https://akhil-rajesh--indeed-jobs-mcp-server.apify.actor/mcp?token=<YOUR_APIFY_TOKEN>`. Keep that URL private, as it carries your token.

Through **Apify's MCP server** (`https://mcp.apify.com`, for Claude, ChatGPT, Cursor and other clients), add the tools with `https://mcp.apify.com?tools=akhil_rajesh/indeed-jobs-mcp-server`. They appear as `akhil_rajesh--indeed-jobs-mcp-server--search_jobs` and so on. Add them that way rather than through Apify's generic `call-actor` tool, which returns the rows only as text.

Then ask in plain words:

- *"Find registered nurse jobs in Toronto posted this week that pay at least $90,000 a year."*
- *"Which companies are hiring Python developers in Berlin? One job per company."*
- *"Are these three Indeed jobs still open?"* (with the links)
- *"Compare remote data analyst pay in London and Manchester."*

### Tools

| Tool | What it returns |
|---|---|
| `search_jobs` | Jobs for up to 3 searches (separate them with `\|`) in a city, region or whole country, with every field below. Takes Indeed's own filters (posted within 1, 3, 7, 14 or 30 days, job type, remote or hybrid, experience level, radius, newest first) and the Actor's (title words, excluded title words and companies, minimum yearly pay, only jobs with pay, Easy apply or employer site, one job per company). Without full descriptions unless asked for |
| `get_jobs` | Jobs by Indeed job key or link: whether each is still listed, with every field and the full description |
| `list_countries` | Indeed's 62 country codes, each site's radius unit and which experience levels it tags (free) |
| `run_actor` | The whole input of [Indeed Jobs Scraper](https://apify.com/akhil_rajesh/indeed-jobs-scraper) in one call, for searches the other tools can't express (several keywords and countries, start URLs) |

The first request starts a Standby run, which took about 6 seconds in testing; after that, a search of 10 jobs was answered in 1 to 2 seconds and a lookup by key in under half a second.

### HTTP API

The same searches as plain HTTP requests, with the same token (header `Authorization: Bearer <token>`):

```bash
curl "https://akhil-rajesh--indeed-jobs-mcp-server.apify.actor/jobs?q=registered%20nurse&l=Toronto,%20ON&country=ca&max=50&days=7&minSalary=80000" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>"
```

| Endpoint | Parameters (defaults in brackets) |
|---|---|
| `GET /jobs` | `q`, `l`, `country`, `max` (50), `days`, `type`, `arrangement`, `level`, `sort`, `radius`, `title`, `excludeTitle`, `excludeCompany`, `minSalary`, `withSalary`, `apply`, `onePerCompany`, `descriptions` (true) |
| `GET /job` | `keys` (job keys or links), `country`, `descriptions` (true) |
| `GET /countries` | none (free) |
| `POST /run` | The Indeed Jobs Scraper input as the JSON body |

Separate several searches, title words or job keys with `|`. The Actor's **Endpoints** tab in Apify Console lists every parameter and lets you try them.

### What each job holds

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

`salaryYearlyMin` and `salaryYearlyMax` turn hourly, daily, weekly and monthly pay into a yearly figure, so an agent can compare a $38.50-an-hour job with a $90,000 salary. `attributes` holds every tag Indeed attaches to a job: benefits, shifts, skills and education included. Fields without a value are left out of a row.

A job, shortened:

```json
{
  "title": "Senior Full Stack Developer",
  "company": "Example Technologies",
  "location": "Toronto, ON M5V 2T6",
  "latitude": 43.6453,
  "longitude": -79.3806,
  "remoteType": "Hybrid work",
  "salaryText": "$110,000–$140,000 a year",
  "salaryYearlyMin": 110000,
  "salaryYearlyMax": 140000,
  "salaryCurrency": "CAD",
  "jobTypes": ["Full-time", "Permanent"],
  "experienceLevels": ["Senior level"],
  "datePosted": "2026-09-16T14:00:00+00:00",
  "applyUrl": "https://careers.example.com/jobs/4821",
  "easyApply": false,
  "companyRating": 3.7,
  "companySize": "1,001 to 5,000",
  "url": "https://ca.indeed.com/viewjob?jk=1a2b3c4d5e6f7890",
  "jobKey": "1a2b3c4d5e6f7890"
}
```

### Searching well

- **Any of Indeed's 62 country sites**, from Canada (`ca`) and the US (`us`) to Germany (`de`), India (`in`) and Japan (`jp`). `list_countries` lists them. When no country is given, the location's country is used.
- **Indeed's search syntax works**: `title:(nurse)` for the title only, `nurse -travel` to leave a word out, `company:(Amazon)` for one employer, `"registered nurse"` for the exact phrase.
- **Search in the local language** outside English-speaking countries (`softwareentwickler` in Germany, `comptable` in France), and write places the way the local site does (`Sydney NSW`, `Mumbai, Maharashtra`, `München`).
- **Leave the location empty for a whole country**, or name a region (`Ontario`, `TX`, `Bayern`). When Indeed cuts a wide search off, the Actor goes on city by city, up to the request's limit.
- **Pay coverage varies by country**: in a September 2026 test, 69% of Canadian jobs and 51% of British ones showed pay, against 17% in Germany and 9% in New Zealand.

### Answers and limits

Every answer carries the `rows`, `notFound` (job keys Indeed no longer lists: free), `notLoaded` (searches Indeed didn't answer), `notRead` (what a limit left out: not charged) and `notes`.

A request that reads nothing gets an `error`, and nothing is charged:

- HTTP 400 for an argument it can't read (a tool error over MCP).
- 503 when Indeed didn't answer or the run was busy (send it again).
- 402 when your spending limit for the run is reached (it lifts when the run ends, after 2 minutes without requests).

A 503 can also carry rows, when the platform stopped the run while a request was being read: those were stored and charged, and `notRead` names the rest.

| | Searches | Jobs | Job keys | Answer size | Time |
|---|---|---|---|---|---|
| **MCP tool call** | 3 | 100 | 50 | about 350 kB | 50 seconds |
| **HTTP request** | 10 | 1,000 | 200 | about 6 MB | 170 seconds |

The MCP limits keep answers inside what MCP clients wait for (60 seconds) and what Apify's MCP server passes on (about 1 MB). **A request that has started runs to its end even if you stop waiting**: Apify's Standby proxy keeps it open, so its jobs are read and charged. Ask for what you need.

### How much does it cost?

Pay-per-event, the same prices per job as Indeed Jobs Scraper:

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

Plus **$0.001** when a Standby run starts, and the run's **platform usage** while it serves you and until it has been idle for 2 minutes, at Apify's usual rates. That's why the Store page's pricing box mentions platform usage. `list_countries`, job keys Indeed no longer lists, and jobs a filter leaves out cost nothing.

### Agents that pay per call

Apify's MCP server doesn't offer Actors with a live endpoint to agents that pay per call with **x402** or **Skyfire**. Those agents can use [Indeed Jobs Scraper](https://apify.com/akhil_rajesh/indeed-jobs-scraper) through `https://mcp.apify.com` instead: it takes the same searches and returns the same rows, as a normal run that starts for each call (a 100-job search took about 10 seconds in testing) instead of a live answer. An agent with an Apify account or API token can use either.

### FAQ

#### Why did a search return fewer jobs than I asked for?

The search ran out of jobs, a filter left the rest out (`notes` counts them), or a limit was reached (`notRead` says which). One search ends at about 1,000 jobs on Indeed. For more, run [Indeed Jobs Scraper](https://apify.com/akhil_rajesh/indeed-jobs-scraper), which has no per-request limits.

#### Can it return only jobs I haven't seen before, or post them to Slack?

Not over the live endpoint, which answers each request on its own and ignores those fields. A normal run of this Actor does both, with the same input as Indeed Jobs Scraper: schedule it, or schedule the scraper. Each Actor keeps its own history of delivered jobs (this one's is `indeed-jobs-mcp-history` by default), because Apify lets an Actor open only the history stores it created itself: a History name the other Actor created stops the run before anything is charged.

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

Many employers don't publish pay, and how often they do varies by country and occupation. `salaryIsEstimated` says whether the employer stated the pay or Indeed estimated it.

#### Why did the experience level filter return every level?

Indeed tags entry, mid and senior level on its US site only. Elsewhere every level comes back and the answer's `notes` say so. **No experience needed** works in every country.

### Other Actors by this developer

- [Indeed Jobs Scraper](https://apify.com/akhil_rajesh/indeed-jobs-scraper): the same Indeed data as scheduled runs: whole countries swept city by city, only new jobs, and Slack, Discord, Teams or Telegram alerts
- [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
- [Wellfound (AngelList) Jobs Scraper - Salary & Equity](https://apify.com/akhil_rajesh/wellfound-jobs-scraper): startup jobs from Wellfound with salary and equity ranges, company size and an exact Y Combinator flag
- [Job Bank Scraper - Canada Jobs, Salary & NOC Codes](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
- [Contact Details Scraper](https://apify.com/akhil_rajesh/contact-details-scraper): emails, phone numbers, social profiles and contact pages from any list of websites, with who runs each business
- [Yahoo Finance Scraper, API & MCP](https://apify.com/akhil_rajesh/yahoo-finance-scraper): quotes, price history, financials and options chains, with an MCP server for AI agents

### 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 vn.indeed.com. This Actor reads publicly available listings only and never signs in to an account.

> **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**, and per-request limits on top (see above)
- **A keyword is required** for every search
- **Entry, mid and senior level are tagged on Indeed's US site only**
- **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
- **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
- If Indeed's search service is unavailable, the endpoint names the searches it didn't answer in `notLoaded` rather than falling back to Indeed's web pages
- Listings change constantly, and a job can close between requests

# Changelog

This Actor's version history is a separate document: https://apify.com/akhil_rajesh/indeed-jobs-mcp-server/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: any of Indeed's 62 country sites. 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=...). URLs from any of Indeed's 62 country sites work.

## `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 posted in this window. Both the job's posting date (datePosted) and the day Indeed listed it must fall inside, so older postings that Indeed lists again are left out. 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.

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

Only jobs Indeed tags with this level. Entry, mid and senior level are tagged on Indeed's United States site only (elsewhere every level is returned, and the run says so); 'No experience needed' works in every country.

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

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

## `titleKeywords` (type: `array`):

Keep only jobs whose title contains at least one of these words or phrases, as whole words, ignoring case and accents ('engineer' matches 'Software Engineer II' but not 'Engineering Manager'; end a word with \* for any ending: 'engineer\*').

## `excludeTitleKeywords` (type: `array`):

Leave out jobs whose title contains any of these words or phrases ('senior', 'intern', 'sales').

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

Leave out jobs from employers whose name contains any of these words (staffing agencies you don't want, your own company). Both the employer's Indeed company page name and the name the job was posted under are checked.

## `minSalary` (type: `integer`):

Leave out jobs whose pay tops out below this yearly amount, in the job's own currency. Hourly, daily, weekly and monthly pay is turned into a yearly figure (2,080 hours, 260 days, 52 weeks, 12 months), shown as salaryYearlyMin and salaryYearlyMax. Jobs that state no pay are kept unless 'Only jobs that show pay' is on.

## `onlyWithSalary` (type: `boolean`):

Leave out jobs without a stated or estimated pay range.

## `applyType` (type: `string`):

Only jobs you can apply to on Indeed (Easy apply), or only jobs that send you to the employer's own site.

## `oneJobPerCompany` (type: `boolean`):

Keep only the first job from each employer (by Indeed's employer key, else the name), for a list of hiring companies rather than of jobs.

## `alertWebhookUrl` (type: `string`):

A Slack incoming webhook, a Discord channel webhook, a Microsoft Teams Workflows webhook, or any HTTPS endpoint that takes JSON (Zapier, Make, n8n). Up to 50 new jobs are posted per run, newest first. The URL is kept secret and masked in logs.

## `telegramBotToken` (type: `string`):

To post to Telegram: your bot's token from @BotFather (123456789:AAH...). Fill in the chat id too. The token is kept secret and masked in logs.

## `telegramChatId` (type: `string`):

The chat the bot posts to: a public channel or group (@mychannel), or a chat id (-1001234567890). Add the bot to the group, or to the channel as an admin that can post.

## `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, a country or your own proxies. Residential and other groups billed per GB or per request aren't used: the run uses the datacenter proxy instead and says so.

## `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-mcp-history",
  "maxResults": 100,
  "fullDescriptions": true,
  "datePosted": "",
  "jobType": "",
  "workArrangement": "",
  "experienceLevel": "",
  "sort": "relevance",
  "applyType": "",
  "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-mcp-server").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-mcp-server").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-mcp-server --silent --output-dataset

```

## MCP server setup

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

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/If2FApPTRRiZqkiqd/builds/3LA84znxBtIX3VEJ2/openapi.json