# Instahyre Jobs Scraper — India Tech Jobs & Hiring Monitor (`memo23/instahyre-jobs-scraper`) Actor

Search and monitor India tech jobs on Instahyre — title, skills, city, apply URL and the full hiring-company profile (headcount, founded year, tagline) on every row. Track only-new postings, filter by skill, city, company or size, and add employer emails. JSON, CSV or Excel.

- **URL**: https://apify.com/memo23/instahyre-jobs-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 132 total users, 45 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 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

## Instahyre Jobs Scraper — India Tech Jobs & Hiring Monitor

Search India's tech job market on Instahyre and watch it change over time. Every row carries the job (title, skills, locations, apply URL) plus the hiring company's full profile — name, tagline, founding year, employee count and description. Run it once for a clean dataset, or turn on monitor mode to get only the postings that are new since your last run, so you catch companies the moment they start hiring. Powered by Instahyre's own JSON API, so runs are fast and rows are exact — no HTML guesswork.

Search by skill and city, paste listing or job URLs, and optionally add employer contact emails to turn each hiring company into an outreach-ready lead.

#### How it works

![How the Instahyre Jobs Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-instahyre.png)

#### ✨ Why use this scraper?

- **API-exact data** — rows come from Instahyre's JSON API, one request per 35 jobs. Fast, cheap, and immune to layout changes.
- **Company intelligence included** — founding year, headcount, tagline and company description ride along on every job row, which most job scrapers skip.
- **Skill search that actually filters** — the `skills` filter binds server-side (verified against row content, since Instahyre ignores several of its own documented parameters).
- **Honest city filtering** — Instahyre's API ignores location parameters, so the city and remote filters are applied to row content on our side; rows that miss the filter are skipped and never billed.
- **Employer emails on demand** — opt-in enrichment discovers the company's website and harvests a contact email, billed only per row where one is found.
- **Bulk-friendly and fail-safe** — paste many URLs or skills; failed requests retry direct then through residential, and produce no billed placeholder rows.

#### 🔁 Hiring monitor — track only what's new

Companies that just started hiring are the freshest lead of all. Turn on `monitoringMode` and the scraper remembers which jobs it has already seen, then on every later run emits only the postings that appeared since — new roles, new companies, new stacks. Point it at a skill (`react`) or a city (`bangalore`), put it on an Apify schedule, and you get a daily feed of who's newly hiring for what, with the company profile and optional email already attached.

Running more than one watch? Give each its own `monitorStateName` (e.g. `bangalore-eng` on one schedule, `remote-sales` on another) and their "already seen" histories stay separate, so neither hides the other's new jobs.

- **First run** emits a baseline of current postings (or skip the baseline and start clean).
- **Later runs** emit only changes, so you pay for signal, not for re-scraping the same board.
- **State is per-actor**, and `resetMonitoringState` clears it when you want a fresh baseline.

This is the difference between a one-off export and a standing hiring-signal feed.

#### 🎯 Use cases

| Who | What they do with it |
|---|---|
| **Recruiters & sourcing teams** | Monitor which companies hire for which stacks across India's tech hubs. |
| **Lead generation** | Companies actively hiring are companies actively buying — enriched with emails, each row is an outreach-ready lead. |
| **Job boards & aggregators** | Clean structured rows with stable ids for deduplicated ingestion. |
| **Market & salary researchers** | Skill demand by city and company size over time. |
| **Founders & analysts** | Track competitor hiring as a growth signal, with founding year and headcount context built in. |

#### 📥 Supported inputs

| Input | Example |
|---|---|
| Skills / keywords / job function | `python`, `react`, `data science`, `product manager`, `sales` |
| City (one or many) | `bangalore`; or several at once: `["bangalore", "pune", "gurgaon"]` |
| Remote only | roles listed under Work From Home |
| Listing URLs | `https://www.instahyre.com/python-jobs-in-bangalore/` |
| Job detail URLs | `https://www.instahyre.com/job-439825-backend-engineer-at-biopeak-bangalore/` |

**Not supported:** candidate-side pages behind login, applying to jobs, and non-instahyre.com domains.

#### ⚙️ Input parameters

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchQueries` | array | `["python"]` | One search walk per skill or keyword |
| `jobFunctions` | array | `[]` | Free-text function search (`product manager`, `sales`, `devops`); merged with `searchQueries` |
| `jobFunctionSlugs` | array | `[]` | Instahyre slugs bound server-side (`backend-development`, `data-science-machine-learning`). Unknown slugs are skipped, not guessed |
| `city` | string | — | Single city; applied to row content (see FAQ) |
| `cities` | array | `[]` | Several cities at once — a job in ANY of them passes. API alias: `locations` |
| `remoteOnly` | boolean | `false` | Work From Home roles only |
| `monitoringMode` | boolean | `false` | Only return jobs not seen on previous runs |
| `emitBaseline` | boolean | `true` | First monitor run: `true` returns all current matches; `false` seeds silently and emits only later-new jobs |
| `includeUnchanged` | boolean | `false` | Monitoring: also re-emit already-seen jobs whose fields did not change, tagged `unchanged` |
| `includeRemoved` | boolean | `false` | Monitoring: after a completed uncapped scan, emit billed `removed` stubs for ids missing since the last complete scan |
| `diversityEmployersOnly` | boolean | `false` | Keep only employers Instahyre flags with a diversity-hiring badge |
| `companyNames` | array | `[]` | Exact Instahyre name first (`companies=`), then partial scan on a miss |
| `trackCompanies` | array | `[]` | Hiring-tracker mode: one row per exact company, not a job list |
| `monitorStateName` | string | — | Name a watch to run several independent monitors from one account. API alias: `stateName` |
| `maxPages` | integer | — | Cap the crawl at N pages per search term (~35 jobs each); `maxItems` still caps billed rows |
| `startUrls` | array | `[]` | Listing or job URLs; override the search fields |
| `enrichEmails` | boolean | `false` | Employer email discovery, billed per found email |
| `maxItems` | integer | `1000` | Hard cap on billed rows |
| `proxy` | object | direct | Direct works; residential fallback kicks in on retries automatically |

#### 📦 Output sample

Real row from a live run:

```json
{
    "type": "job",
    "source": "instahyre",
    "jobId": "439825",
    "jobUrl": "https://www.instahyre.com/job-439825-backend-engineer-at-biopeak-bangalore/",
    "title": "Backend Engineer",
    "companyName": "Biopeak",
    "location": "Bangalore",
    "remote": false,
    "skills": ["Java", "Python", "CI / CD", "Golang", "Microservices", "Node.js", "SQL"],
    "companyTagline": "Personalized longevity clinic",
    "companyFounded": 2024,
    "companyEmployeeCount": 10,
    "companyDescription": "Biopeak is a personalised longevity clinic…",
    "companyImage": "https://media.instahyre.com/images/profile/…",
    "acceptsOutstationCandidates": true,
    "applyType": "internal",
    "applyUrl": "https://www.instahyre.com/job-439825-backend-engineer-at-biopeak-bangalore/",
    "scrapedAt": "2026-08-22T12:07:41.512Z"
}
```

Rows follow the portfolio-wide canonical job shape (same field names as the CutShort, Naukri and RemoteOK scrapers), so multi-source pipelines map one column layout across all of them.

#### 🔑 Output fields

Every job row carries these fields (missing values come back `null`, never guessed):

| Field | What it is |
|---|---|
| `jobId` | Stable Instahyre job id — use it as the dedup key |
| `title` | Job title |
| `jobUrl` / `applyUrl` | Listing URL and where to apply |
| `applyType` | `internal` (apply on Instahyre) or `external` |
| `companyName` | Hiring company |
| `location` / `remote` | City, and whether the role is Work From Home |
| `skills` | Array of the stack the role asks for |
| `companyTagline` | One-line company positioning |
| `companyFounded` | Founding year — a maturity signal |
| `companyEmployeeCount` | Headcount — segment startups vs enterprises |
| `companyDescription` | Full company blurb |
| `companyImage` | Logo URL |
| `acceptsOutstationCandidates` | Whether non-local applicants are considered |
| `candidateTitle` | Instahyre's candidate-facing title when it differs from `title` |
| `isDiversityEmployer` | Employer carries Instahyre's diversity-hiring badge |
| `isFeaturedEmployer` | Employer carries Instahyre's featured badge |
| `contentHash` | Fingerprint of title / skills / location / company used for `updated` detection |
| `contactEmail` | Employer email (only when `enrichEmails` is on and one is found) |
| `changeType` | In monitoring mode: `new`, `updated` (public fields changed), `unchanged` (only with `includeUnchanged`), or `removed` (only with `includeRemoved` after a complete scan) |
| `scrapedAt` | ISO timestamp of the run |

Every search run also writes `MARKET_SNAPSHOT` to the run's key-value store: live facet counts (total jobs, top companies, top locations, function mix, company-size and job-type splits) for the filters you used. That record is not a dataset row and is not billed.

#### Coming from another Instahyre scraper?

| You asked for | getascraper / themineworks | This actor |
|---|---|---|
| Server-side function slugs | `jobFunctionSlugs` | Same key, resolved against Instahyre's live catalog |
| Diversity-employer filter | `diversityEmployersOnly` | Same, from the list payload badge |
| New / updated / removed | `monitorMode: changes_only` | `monitoringMode` + `updated` always; `includeRemoved` opt-in so existing schedules are not surprise-billed |
| Market facet snapshot | KV `MARKET_SNAPSHOT` | Same key, not billed |
| Company hiring tracker | `trackCompanies` | Same key — one billed row per exact employer (open-role count, location/skill mix, deltas). Other search filters are ignored |
| Exact company-name lookup | `companyNames` hits `companies=` first | Same: recognised names bind server-side; unrecognised names fall back to a partial scan |
| Recruiter / agency / experience | `includeDetails` / `excludeAgencyPosted` | Public list, job JSON and JSON-LD do not publish those fields; we do not invent them |
| `locations` / `stateName` / `maxJobs` / `proxyConfiguration` | Their key names | Accepted as aliases; `cities`, `monitorStateName`, `maxItems`, `proxy` stay the published keys |

The company fields are what most job scrapers drop — they turn a job feed into a company-intelligence feed you can segment by size, age and stack.

#### ❓ FAQ

**Can I get a daily feed of only new jobs?**
Yes — that's monitor mode. Turn on `monitoringMode`, put the actor on an Apify schedule, and each run returns only postings that appeared since the last one. See the Hiring Monitor section above.

**How do I watch one company's hiring instead of a job list?**
Pass exact Instahyre names in `trackCompanies` (the spelling from a `MARKET_SNAPSHOT` topCompanies row). The run returns one billed row per company: open-role count, location mix, skill mix, and new/closed job ids versus the last run. Unknown names are skipped and not billed.

**What if I type a company name Instahyre does not recognise?**
`companyNames` tries Instahyre's exact `companies=` token first. A miss (`{"companies":["Invalid company"]}`) falls back to a partial match on the scanned pages. `trackCompanies` does not fall back — it skips the unknown name.

**How does the city filter work if the API ignores location parameters?**
The skill filter narrows the walk server-side; the city/remote filters then keep only rows whose location matches, on our side. Skipped rows are never billed. The trade-off: a very narrow city in a broad skill can take a few extra unbilled pages to fill your `maxItems`. Pass several cities in `cities` to widen the net — a job in any of them passes.

**Can I search by job function, not just a skill?**
Two ways. `jobFunctions` / `searchQueries` are free text (`product manager`, `sales`) and walk the skill index. `jobFunctionSlugs` uses Instahyre's own ids (`backend-development`) and is the filter the API actually applies server-side — verified: `job_functions=1` drops the board from ~13.6k to the matching function. Unknown slugs are skipped with a warning.

**Can I run more than one saved monitor?**
Yes — give each watch its own `monitorStateName`. Each name keeps an independent "already seen" history, so a `bangalore-eng` schedule and a `remote-sales` schedule never mask each other's new jobs.

**Does it include salary?**
Instahyre's public API does not expose salary on listings, so there is no salary column pretending otherwise.

**What does `enrichEmails` cost?**
It is billed as an additional-data event only on rows where an email was actually found — see the pricing tab. Discovery uses the company name plus a business-match guard, so unrelated domains are rejected rather than guessed.

**Do I need a proxy?**
No. Instahyre's Cloudflare passes browser-grade TLS from a direct connection; the retry ladder adds residential automatically if a request struggles.

#### 💬 Support

Open an issue on the actor's **Issues tab** in Apify Console — answered within 1–2 business days.

#### 🛠 Additional services

Scheduled hiring-signal feeds, multi-board merges (Instahyre + CutShort + Naukri), or delivery straight to your CRM — custom builds available, contact me through the actor page.

#### 🔎 Explore more scrapers

Same developer, same canonical row shape: [CutShort Jobs](https://apify.com/memo23/cutshort-jobs-scraper), [Naukri](https://apify.com/memo23/naukri-scraper), [RemoteOK](https://apify.com/memo23/remoteok-jobs-scraper), [Remote Jobs Aggregator](https://apify.com/memo23/remote-jobs-aggregator) — full portfolio at [memo23 on Apify Store](https://apify.com/memo23).

#### 🤖 For AI Agents & LLM Apps

Stable, typed JSON with a `type` discriminator and canonical field names shared across the whole jobs family — an agent that learns one scraper's shape can drive them all. Skill search maps cleanly to tool calls; keep `maxItems` low per call for cost control.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Instahyre or its operators. All trademarks are the property of their respective owners. The scraper accesses only publicly available listing data — no login, no candidate profiles, no private information. Users are responsible for compliance with Instahyre's Terms of Service, applicable data-protection law (GDPR, DPDP Act, CCPA), and their own organisation's obligations, particularly when using contact enrichment for outreach.

***

### SEO Keywords

instahyre scraper, instahyre jobs scraper, india tech jobs scraper, india hiring monitor, hiring signals india, new job postings tracker india, instahyre jobs api, scrape instahyre, bangalore startup jobs data, india hiring data, instahyre company data, tech recruitment leads india, jobs api india, startup hiring signals india, who is hiring india, apify instahyre, india jobs by function, product manager jobs india, data science jobs india, multi city job search india, bangalore pune hyderabad jobs, engineering jobs india scraper, sales jobs india data

# Actor input Schema

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

One search walk per entry — e.g. `python`, `react`, `data science`. Leave empty (with no URLs) to walk the whole board, newest first.

## `jobFunctions` (type: `array`):

Search by job function — e.g. "product manager", "sales", "devops", "data science". Each runs one search walk, exactly like Skills/keywords, and the two lists are merged. Use this to pull a whole function across companies. For Instahyre's own function slugs (server-side), use Job function slugs below.

## `jobFunctionSlugs` (type: `array`):

Instahyre's own function slugs, bound server-side — e.g. `backend-development`, `full-stack-development`, `data-science-machine-learning`, `frontend-development`, `product-management`. Resolved against Instahyre's live /api/v1/job_function/ list; unknown slugs are skipped with a warning, never guessed. Numeric ids are also accepted. Leave empty to not filter by function id. Default: none.

## `city` (type: `string`):

Optional city filter shared by every search — e.g. `bangalore`, `gurgaon`, `hyderabad`, `mumbai`.

## `cities` (type: `array`):

Filter to several cities at once — a job in ANY of them passes (e.g. \["bangalore", "pune", "gurgaon"]). Merged with the single City field above. Instahyre ignores location server-side, so rows are filtered here and non-matches are never billed. API alias: `locations` is accepted and merged into this list (the `cities` key is unchanged).

## `remoteOnly` (type: `boolean`):

Only roles listed under Work From Home.

## `skills` (type: `array`):

Keep only jobs whose skill tags match, e.g. `react`, `python`, `sql`. Case-insensitive, partial match.

## `skillMatch` (type: `string`):

`Any` keeps a job when one listed skill matches; `All` requires every listed skill.

## `keywords` (type: `array`):

Keep only jobs matching these terms across title, skills, company and location. Case-insensitive.

## `keywordMatch` (type: `string`):

`Any` keeps a job when one keyword matches; `All` requires every keyword.

## `companyNames` (type: `array`):

Allowlist of employer names. Each name is tried first as Instahyre's exact `companies` token (one request; case-insensitive). A recognised name binds server-side so the walk never pages the rest of the board. An unrecognised name falls back to a case-insensitive partial match across the scanned pages. Dropped rows are never billed. Leave empty to keep all companies.

## `trackCompanies` (type: `array`):

Exact Instahyre company names to track as a hiring profile instead of listing jobs. When this is non-empty the actor switches to tracker mode: one billed row per company with open-role count, location mix, skill mix, and (from the second scheduled run onward) new/closed job ids. Use the name Instahyre shows — e.g. from MARKET_SNAPSHOT topCompanies. Unknown names are skipped with a warning and are not billed. All other search filters are ignored in this mode.

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

Skip any job containing one of these terms in its title, skills, company or location.

## `diversityEmployersOnly` (type: `boolean`):

Keep only jobs from employers Instahyre flags with a diversity-hiring badge (`isDiversityEmployer: true` on the list payload). Dropped rows are never billed. Default: false.

## `companySize` (type: `string`):

Filter by employer headcount band.

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

Filter by employment type. Job type only appears on the detail page, so this turns on 'Fetch job details' automatically (those detail fetches are billed).

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

Listing pages (`instahyre.com/python-jobs-in-bangalore/`) or job detail pages (`/job-{id}-…/`). When present, the search fields above are ignored.

## `enrichEmails` (type: `boolean`):

Discover the hiring company's website and harvest a contact email from it. Billed per row with a found email — see the pricing tab.

## `includeDetails` (type: `boolean`):

Fetch each job's public page and add the full description, employment type, exact location and posting dates. One extra request per job.

## `monitoringMode` (type: `boolean`):

When enabled, jobs whose Instahyre ID has already been delivered to you are skipped unless their public fields changed (`changeType` = `updated`) or you turn on Include unchanged. The first run after enabling monitoring returns every match and builds your baseline; every later run returns new and updated postings. Combine with Apify's scheduler for a 'jobs posted since last run' feed.

## `resetMonitoringState` (type: `boolean`):

One-shot: clear the saved 'jobs already seen' record at the start of this run. Use after changing the search, to rebuild the baseline, or to recover from a missed delivery. No effect when monitoring mode is off.

## `monitorStateName` (type: `string`):

Name this monitor so one account can run several independent 'only-new' watches without their seen-job history colliding — e.g. "bangalore-eng" for one schedule and "remote-sales" for another. Leave empty for a single default baseline. Only used when Monitoring mode is on. API alias: `stateName`.

## `emitBaseline` (type: `boolean`):

Only used with Monitoring mode. ON (default): the first run returns every current match and remembers them. OFF: the first run silently records what exists now and emits nothing, so every later run returns only jobs that appeared after it — no baseline flood, no first-run billing.

## `includeUnchanged` (type: `boolean`):

Only used with Monitoring mode. OFF (default): return only new and updated postings. ON: also re-emit jobs already seen whose public fields did not change, tagged `changeType` = `unchanged`, so every run is a full snapshot. Re-emitted rows are billed like any other.

## `includeRemoved` (type: `boolean`):

Only used with Monitoring mode. OFF (default) so existing only-new schedules are not surprise-billed. ON: after a completed (uncapped) scan, emit a stub row with `changeType` = `removed` for each job id that was present on the last complete scan and is missing now. A run that hits Max results or Max pages never marks jobs as removed. Each removed stub is billed as a job. Default: false.

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

Hard cap on billed rows for the run — your spend guard. API alias: `maxJobs`.

## `maxPages` (type: `integer`):

Cap the crawl at this many result pages per search term (~35 jobs each). Optional — Max results still limits billed rows; this bounds how deep the walk goes regardless of matches.

## `maxConcurrency` (type: `integer`):

Parallel fetches (the API pages at 35 rows per request, so most runs need very few).

## `maxRequestRetries` (type: `integer`):

Retries per request before it is skipped.

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

The site answers a direct connection (the built-in retry ladder adds a residential fallback automatically). Configure a proxy only if you want all traffic through it. API alias: `proxyConfiguration`.

## Actor input object example

```json
{
  "searchQueries": [
    "python"
  ],
  "jobFunctions": [
    "product manager",
    "sales"
  ],
  "jobFunctionSlugs": [
    "backend-development"
  ],
  "cities": [
    "bangalore",
    "pune"
  ],
  "remoteOnly": false,
  "skills": [],
  "skillMatch": "any",
  "keywords": [],
  "keywordMatch": "any",
  "companyNames": [],
  "trackCompanies": [],
  "excludeKeywords": [],
  "diversityEmployersOnly": false,
  "companySize": "any",
  "jobType": "any",
  "startUrls": [],
  "enrichEmails": false,
  "includeDetails": false,
  "monitoringMode": false,
  "resetMonitoringState": false,
  "emitBaseline": true,
  "includeUnchanged": false,
  "includeRemoved": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "maxRequestRetries": 5,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

One row per job with title, company profile, skills, location, diversity/featured badges, apply URL, and optional changeType.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "python"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/instahyre-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["python"],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/instahyre-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 '{
  "searchQueries": [
    "python"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call memo23/instahyre-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/instahyre-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/x4L8aure7aGcZKuiv/builds/zhKt5zbjxJh80991g/openapi.json