# Instahyre Jobs Scraper | India Tech Jobs API with Descriptions (`data_daemon/instahyre-jobs-scraper`) Actor

$0.80 per 1,000 jobs, full description included | Scrape Instahyre India tech jobs by skill, city, experience, company and company size. Only-new mode + skipJobIds for daily schedules. JSON API, no login, no proxy.

- **URL**: https://apify.com/data_daemon/instahyre-jobs-scraper.md
- **Developed by:** [Daemon Data](https://apify.com/data_daemon) (community)
- **Categories:** Jobs, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 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 API with Full Descriptions

**Instahyre Jobs Scraper** is a pay-per-result Apify Actor that returns [Instahyre](https://www.instahyre.com/) job listings (the hiring platform Indian product companies and startups use for engineering, data, product and design roles) as JSON, CSV or Excel. It is for tech recruiters and staffing agencies, job aggregators, B2B sales teams that track startup hiring, workforce analysts and job-alert builders. Each row has the full job description (HTML and plain text), experience range, skills, job functions, posting date and the company profile (headcount, founding year, tagline, website, logo); filters cover skill or role, city, experience, company and company size. Price: $0.80 per 1,000 jobs with the description included, plus $0.001 per run; no login, cookies, proxy or browser. On 21 October 2026 Instahyre listed 12,743 open tech jobs, 6,764 of them in Bangalore and 1,095 work from home; `python` matched 4,300.

**$0.80 per 1,000 jobs, full description included**, plus $0.001 per run. No login, cookies, proxy or browser: the Actor reads the JSON API behind the Instahyre website and the public job pages. Apify's free plan ($5 credit every month) covers about **6,000 jobs with full descriptions**. Built for schedules: switch on **Only new jobs since the last run** and a daily run returns, and charges for, only the jobs you have not received before. Jobs you already have can also be passed in `skipJobIds`.

> Live check, 21 Oct 2026: `python` matched **4,300** open Instahyre jobs (2,600 in Bangalore), `react` 1,600, `data science` 8,000 (title and skill-tag matching is broad), `devops` work-from-home 134. A 50-job run with descriptions takes well under a minute on the Apify platform and costs $0.04 plus the $0.001 start fee.

### Who buys Instahyre data, and what for

| You are | What this Actor gives you |
|---|---|
| **Tech recruiters and staffing agencies** | A daily list of new openings by skill, city, experience band and company size, with the hiring company's headcount and founding year, so you know which startups and product companies are hiring right now. |
| **Job aggregators and HR-tech products** | Instahyre as a source with stable job IDs (`dedupKey`), full JD text, de-duplication across keywords and runs, and an API you can call on a schedule. Same conventions as the IIMJobs, Hirist and Foundit Actors by the same publisher. |
| **B2B sales and lead generation** | A company hiring five backend engineers is buying cloud, tooling and services. Each row carries the company name, size, tagline, website and logo. |
| **Workforce and market analysts** | Demand by skill, city, experience band and company size over time; share of remote roles; which skills large companies ask for versus startups. |
| **Candidates and job-alert builders** | Your own alert for `golang` jobs at small companies in Bangalore, delivered to a sheet, Slack or email the moment they appear. |
| **AI agents (MCP)** | Ask Claude or ChatGPT "new Python jobs in Hyderabad at startups posted this week" and let it call this Actor through Apify's MCP server. |

### Quick start (about a minute)

1. Click **Try for free**. The form is pre-filled with `python`.
2. Optionally add skills or roles (`react`, `data science`, `product management`), cities (`Bangalore`, `Hyderabad`, `Work From Home`), a company size and **Posted within (days)** = `30`.
3. Click **Start**. 50 jobs with full descriptions take well under a minute and cost **$0.04**.
4. Download the results as JSON, CSV or Excel, or save the input as a task, tick **Only new jobs since the last run** and **schedule it daily** to get a fresh feed in Google Sheets, a webhook, Make, Zapier or n8n.

**From code** (returns the jobs in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~instahyre-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["python"], "locations": ["Bangalore"], "companySizes": ["small", "medium"], "maxJobs": 100}'
```

**From an AI assistant:** add the MCP connector `https://mcp.apify.com/?tools=data_daemon/instahyre-jobs-scraper` in Claude, ChatGPT, Cursor or VS Code.

Need other India boards too? [IIMJobs Jobs Scraper](https://apify.com/data_daemon/iimjobs-jobs-scraper), [Hirist.tech Jobs Scraper](https://apify.com/data_daemon/hirist-jobs-scraper) and [Foundit Jobs Scraper](https://apify.com/data_daemon/foundit-jobs-scraper) by the same publisher use the same `queries` / `locations` / `onlyNewSinceLastRun` / `skipJobIds` / `RUN-SUMMARY` conventions, so one pipeline handles all four boards.

### Input

```json
{
    "queries": ["python", "golang"],
    "locations": ["Bangalore", "Work From Home"],
    "companySizes": ["small", "medium"],
    "minExperience": 2,
    "maxExperience": 6,
    "postedWithinDays": 30,
    "includeDescription": true,
    "maxJobsPerQuery": 50
}
```

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array | Skills or roles, one Instahyre search per item, matched against job titles and skill tags (`python`, `react`, `data science`, `java developer`). A job found by two keywords is saved and charged once. Required; `skills`, `query`, `keywords` and `search` are accepted as aliases. |
| `locations` | array | Optional cities as Instahyre lists them: `Bangalore`, `Mumbai`, `Delhi`, `Gurgaon`, `Noida`, `Hyderabad`, `Chennai`, `Pune`, `Kolkata`, `Ahmedabad`, `Work From Home`; regions (`South India`) and about 300 smaller cities also work. Several cities = any of them. Applied by the site. `Bengaluru`, `Gurugram`, `Bombay`, `New Delhi` and `Remote` are mapped; an unknown name is ignored and reported in the status message. |
| `companySizes` | array | Any of `small` (under 100 employees), `medium` (100-1,000), `large` (over 1,000). Applied by the site. |
| `companies` | array | Only jobs posted by these companies (`Amazon`, `Deutsche Telekom Digital Labs`). With an empty keyword list this watches everything a company posts. |
| `jobType` | string | `all` (default), `full-time` or `internship`. |
| `experienceYears` | integer | Instahyre's own filter: jobs open to a candidate with exactly this many years. Applied by the site, so nothing outside it is fetched. |
| `minExperience` / `maxExperience` | integer | Experience band in years (0-30), overlap semantics: a 3-6 year job matches `minExperience: 5`. Read from each job page; jobs that state no range are kept. |
| `postedWithinDays` | integer | Only jobs posted in the last N days (1-365). Instahyre keeps jobs open for months and its search has no date filter, so the Actor reads the posting date from each job page and leaves out older jobs without charging; in only-new mode those are remembered too, so later runs do not re-check them. |
| `includeDescription` | boolean | Fetch the public job page for each job (default `true`, one extra request per job, same price): full description, posting date, experience range, employment type, job functions and company website. Off = listing fields only (title, company profile, cities, skills, URL), about three times as fast. |
| `maxJobsPerQuery` | integer | Stop a keyword after this many new jobs (default 50). The site serves 35 jobs per page, so 1,000 jobs are about 29 search requests. |
| `maxJobs` | integer | Hard cap on saved jobs for the whole run (0 = no cap). |
| `onlyNewSinceLastRun` | boolean | Deliver only jobs that an earlier run with the same `stateName` has not delivered; skipped jobs are not charged (default `false`). |
| `stateName` | string | Name of this saved search's memory for `onlyNewSinceLastRun`. Derived from the keywords, cities and filters when empty. Use a new name to start over. |
| `skipJobIds` | array | Job `id`s you already have, as an array of strings or numbers. Skipped before any page fetch and never charged. Large arrays are fine. |
| `proxyConfiguration` | object | Optional (Advanced). Instahyre answers Apify's datacenter IPs directly, so none is needed. |

Bad input never fails the run: unknown fields are ignored with a warning, a reversed experience range is swapped, an unknown city is dropped and named in the status message, a keyword with no matches ends with `Saved 0 jobs`, and an empty keyword list with a city, company or size filter still searches that filter.

### Output

One record per job. Example from a real run on 21 Oct 2026 (description shortened):

```json
{
    "id": 446412,
    "dedupKey": "instahyre:446412",
    "url": "https://www.instahyre.com/job-446412-python-engineer-at-nineleaps-2-bangalore-hyderabad/",
    "applyUrl": "https://www.instahyre.com/job-446412-python-engineer-at-nineleaps-2-bangalore-hyderabad/",
    "title": "Python Engineer",
    "company": {
        "id": 5003,
        "name": "Nineleaps",
        "tagline": "We build high performance solutions",
        "about": "Nineleaps are enablers of Digital Transformation across industries, helping partner companies become future ready…",
        "founded": 2014,
        "employeeCount": 200,
        "size": "medium",
        "logo": "https://media.instahyre.com/images/profile/base/employer/5003/dcac758458/nineleaps.webp",
        "website": "https://www.nineleaps.com/",
        "featured": false,
        "diversityEmployer": false
    },
    "locations": ["Bangalore", "Hyderabad"],
    "remote": false,
    "acceptsOutstation": true,
    "experienceMinYears": 2,
    "experienceMaxYears": 4,
    "employmentType": "FULL_TIME",
    "skills": ["FastAPI", "MySQL", "PostgreSQL", "Python", "SQL"],
    "functions": ["Backend Development", "Full-Stack Development", "Other Software Development"],
    "postedAt": "2026-10-09T00:00:00.000Z",
    "descriptionHtml": "<p><strong>Responsibilities: </strong></p><ul><li>Backend Development: Design, develop, and maintain robust, scalable…",
    "description": "Responsibilities:\nBackend Development: Design, develop, and maintain robust, scalable, and high-performance backend systems using Python and FastAPI…",
    "query": "python",
    "scrapedAt": "2026-10-21T05:42:36.132Z"
}
```

| Field | Notes |
| --- | --- |
| `id`, `dedupKey`, `url`, `applyUrl` | Instahyre job id, a stable `instahyre:<id>` key for your own de-duplication, and the public job page (applications go through Instahyre, so `applyUrl` is the same page). |
| `title`, `skills` | As tagged by the employer; `skills` is Instahyre's skill-tag list for the job. |
| `company.*` | `name`, `tagline`, `about` (Instahyre's own note on the company), `founded`, `employeeCount` with a `size` band (`small` under 100, `medium` 100-1,000, `large` over 1,000), `logo`, `website`, and the site's `featured` / `diversityEmployer` badges. |
| `locations`, `remote`, `acceptsOutstation` | City names as Instahyre spells them (`Work From Home` for remote roles, with `remote: true`), and whether the employer considers candidates from other cities. |
| `experienceMinYears`, `experienceMaxYears`, `employmentType`, `functions` | From the job page: the stated experience band, `FULL_TIME` or `INTERN`, and Instahyre's job-function tags (`Backend Development`, `Data Science / Machine Learning`, …). |
| `postedAt` | Posting date from the job page (day precision, as ISO midnight UTC). `null` when `includeDescription` is off. |
| `descriptionHtml`, `description` | Full JD as HTML and plain text (`includeDescription: true`); `null` when the page has none. |
| `query`, `scrapedAt` | The keyword that found the job and the collection time. |

Recruiter names shown on job pages are not output. Download as JSON, CSV, Excel, or push to Google Sheets, webhooks and other Apify integrations. Field names are stable; new fields are only added, so your Sheets, Zapier or Make mappings keep working.

### Scheduling & automation

The heavy users of this Actor run it on a schedule with a short keyword list and a city or company-size filter, and let the Actor remember what it has already delivered.

**Recipe: skills × cities, only new jobs, every morning**

```json
{
    "queries": ["python", "golang", "node.js"],
    "locations": ["Bangalore", "Hyderabad", "Work From Home"],
    "companySizes": ["small", "medium"],
    "onlyNewSinceLastRun": true,
    "stateName": "backend-startups-daily",
    "maxJobsPerQuery": 500
}
```

1. Paste the input, click **Save as task**, then **Schedules → Create schedule → Daily** (for example `0 8 * * *`, 08:00 IST) and add the task.
2. The first run delivers every matching job (set `maxJobsPerQuery` high enough to take the whole list, or add `postedWithinDays` to start from recent postings only). Every later run delivers only the jobs that were not delivered before, and **skipped jobs are not charged**. The memory lives in a key-value store named `instahyre-jobs-state` in your own Apify account, one record per `stateName`, and forgets ids after 120 days.
3. Give each saved search its own `stateName` (or leave it empty and the Actor derives one from the keywords, cities and filters). Change the name to start over.
4. Already de-duplicating on your side? Pass the `id`s you have in `skipJobIds` instead; they are skipped before any page fetch and never charged.

**Where the results go**

- **Integrations tab of the task**: Google Sheets (append rows), Slack or email (a message per run), or a **webhook** to your backend when the run finishes.
- **Make, Zapier, n8n**: use the Apify module/node with the task id, or poll the dataset with the API call below.
- **Every run writes a `RUN-SUMMARY` record** to its key-value store: keywords, jobs found, new, filtered, skipped (already delivered / `skipJobIds`) and charged counts, so a webhook consumer can decide what to do without opening the dataset.

**Synchronous API call** (waits for the run and returns the new jobs):

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~instahyre-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["python"], "locations": ["Bangalore"], "onlyNewSinceLastRun": true, "stateName": "python-blr-daily", "maxJobsPerQuery": 500}'
```

### Pricing and what a month costs

Pay per event. Platform compute is included; the Actor runs in 512 MB, so the start fee is always a single event.

| Event | Price | When it is charged |
|---|---|---|
| Job | $0.0008 | Each job saved to your dataset, full description included |
| Actor start | $0.001 | Once per run |

That is **$0.80 per 1,000 jobs with full descriptions**. Jobs skipped by **Only new jobs since the last run**, `skipJobIds`, de-duplication across keywords or your date and experience filters are never charged.

**Plan discounts:** prices above are for the Free and Starter plans; Scale plans pay 15% less ($0.68 per 1,000) and Business plans 30% less ($0.56 per 1,000).

| How teams use it | Volume (measured 21 Oct 2026) | Cost |
|---|---|---|
| Quick look: 50 `python` jobs with descriptions | 50 jobs, 1 run | $0.041 |
| One-off export: every open `react` job in Bangalore | about 900 jobs, 1 run | $0.72 |
| Full export of one skill: all open `python` jobs in India | about 4,300 jobs, 1 run | $3.44 |
| Daily feed, only new jobs: `golang` at small companies | about 200 jobs on the first run, then a few a day | about $0.25 a month after the first run |
| Daily feed, only new jobs: 10 skills × 3 cities, about 60 new jobs a day | 1,800 jobs, 30 runs | about $1.50 a month |

Apify's free plan includes $5 of usage a month: about 6,000 jobs with descriptions, enough for a trial and several small daily feeds.

### Tips

- Keyword matching is broad (titles and skill tags), so `data science` also returns data-engineering roles; add `companySizes`, `experienceYears` or a city to narrow it before you raise `maxJobsPerQuery`.
- `experienceYears`, `companySizes`, `companies`, `jobType` and `locations` are applied by the site before anything is fetched, so they make runs fast and cheap; `postedWithinDays` and the experience band are checked on each job page.
- Set `includeDescription: false` when you only need titles, companies, cities and skills; it makes a run about three times as fast.
- `maxExperience: 1` is a good early-career filter; `jobType: "internship"` lists the internships (a few dozen at any time).
- Set a **maximum cost per run** on the task; the Actor stops cleanly at the limit and says so in the status message.

### FAQ

**How much does it cost to scrape Instahyre?**

$0.0008 per job with its full description plus $0.001 per run, so 100 jobs cost about $0.08 and a 50-jobs-a-day feed about $1.25 a month.

**Is there an official Instahyre API?**

No public one. This Actor reads the JSON that the Instahyre website itself loads for its job search, plus the public job pages, and exposes them as a REST API with schedules, webhooks and only-new-jobs runs.

**Does it return the full job description?**

Yes, as HTML and plain text, plus the experience range, posting date, job functions, skills and the company profile with headcount, founding year and website.

**Why is the posting date old on many jobs?**

Instahyre keeps a job open until the employer closes it, so a feed without `postedWithinDays` includes jobs posted months ago. Use `postedWithinDays` for recent postings, or only-new mode, which after the first run delivers only jobs that are new on the site.

**Does it include salaries or applicant counts?**

No. Instahyre does not publish salary ranges or applicant counts on public job pages, and this Actor only reads public data.

**Why does a city return nothing?**

The site only accepts the location names it lists; the Actor maps the common alternative spellings and names any location it had to ignore in the status message. Use `Bangalore`, `Delhi`, `Gurgaon`, `Noida`, `Mumbai`, `Hyderabad`, `Chennai`, `Pune`, `Kolkata`, `Ahmedabad` or `Work From Home`.

**Do I need a proxy or login?**

No.

### Related Actors by Daemon Data

- [Hirist.tech Jobs Scraper](https://apify.com/data_daemon/hirist-jobs-scraper) – India IT and tech jobs with full descriptions, same scheduling conventions as this Actor
- [IIMJobs Jobs Scraper](https://apify.com/data_daemon/iimjobs-jobs-scraper) – India's MBA, finance, consulting and management jobs with full descriptions and only-new mode
- [Foundit Jobs Scraper](https://apify.com/data_daemon/foundit-jobs-scraper) – foundit.in (Monster India) jobs with full descriptions, only-new mode for daily feeds
- [Oracle Jobs Scraper](https://apify.com/data_daemon/oracle-hcm-jobs-scraper) – every job on any Oracle Recruiting Cloud (Oracle HCM) career site
- [India IPO Tracker](https://apify.com/data_daemon/india-ipo-tracker) – live IPO GMP, subscription and listing data for India
- [Tickertape India Stocks Scraper](https://apify.com/data_daemon/tickertape-stocks-scraper) – NSE/BSE fundamentals, shareholding and screener
- [Dubai Property Transactions](https://apify.com/data_daemon/dubai-property-transactions) – Dubai Land Department sales, mortgages and gifts
- [UK Gazette Insolvency Notices](https://apify.com/data_daemon/uk-gazette-insolvency-notices) – winding-up petitions, administrations and liquidations
- [Luma Events Scraper](https://apify.com/data_daemon/luma-events-scraper) – lu.ma events by city, topic or organiser calendar, with hosts and ticket info

### Support

Found a bug or need another field or filter? Open an issue on the Issues tab; issues are usually answered within a day. Custom variants of this Actor are available on request.

A quick review on the actor page helps other users find it.

### Disclaimer

This Actor collects publicly available job listings for informational purposes and deliberately leaves out recruiters' personal details. Respect the source website's terms of use and applicable data-protection laws when using the data.

# Actor input Schema

## `queries` (type: `array`):

One Instahyre search per item, matched against job titles and skill tags, e.g. `python`, `react`, `data science`, `devops`, `product management`, `java developer`. Put cities in `locations`. A job found by two keywords is saved and charged once. Leave the list with one item for a quick first run.

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

Optional. Cities as Instahyre lists them: `Bangalore`, `Mumbai`, `Delhi`, `Gurgaon`, `Noida`, `Hyderabad`, `Chennai`, `Pune`, `Kolkata`, `Ahmedabad`, or `Work From Home` for remote roles; regions such as `South India` and about 300 smaller cities also work. Several cities = any of them. Common alternative spellings (`Bengaluru`, `Gurugram`, `Bombay`, `Remote`) are mapped; an unknown name is ignored with a note in the status message. Leave empty for all of India.

## `minExperience` (type: `integer`):

Only jobs whose stated experience range reaches at least this many years (0-30). Checked on each job page; jobs that state no range are kept.

## `maxExperience` (type: `integer`):

Only jobs whose stated experience range starts at or below this many years (0-30). `1` or `2` is a good early-career filter.

## `experienceYears` (type: `integer`):

Instahyre's own experience filter: only jobs open to a candidate with exactly this many years (the job's range must cover it). Applied by the site before anything is fetched, so it is the cheapest way to narrow a search; combine with `minExperience`/`maxExperience` for a band.

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

Only jobs posted in the last N days (1-365). Instahyre keeps jobs open for months and its search has no date filter, so the Actor reads the posting date from each job page and leaves out older jobs without charging. In only-new mode the jobs that are left out are remembered too, so later runs do not re-check them.

## `companySizes` (type: `array`):

Optional. Any of `small` (under 100 employees), `medium` (100-1,000) and `large` (over 1,000). Several values = any of them. Applied by the site.

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

`all` (default), `full-time` or `internship`. Applied by the site.

## `companies` (type: `array`):

Optional. Only jobs posted by these companies, e.g. `Amazon`, `Deutsche Telekom Digital Labs`. Several names = any of them. Applied by the site; combine with an empty keyword list to watch everything a company posts.

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

On (default): one extra request per job reads the public job page and adds the full description (HTML and plain text), posting date, experience range, employment type, job functions and the company website. The price per job is the same either way. Off: listing fields only (title, company profile, cities, skills, URL), about three times as fast, enough for counting jobs or sizing a market.

## `maxJobsPerQuery` (type: `integer`):

Stop a keyword after this many new jobs (default 50). Cost: $0.0008 per job with its description, so 50 jobs = $0.04. Raise it for full exports: `python` alone matches about 4,300 open jobs and the site serves 35 per page.

## `maxJobs` (type: `integer`):

Hard cap on saved jobs for the whole run across all keywords (0 = no cap).

## `onlyNewSinceLastRun` (type: `boolean`):

On: deliver only jobs that an earlier run with the same `stateName` has not already delivered, and skip the rest without charging. Set `maxJobsPerQuery` high enough for the first run to take the whole result list (or add `postedWithinDays`), so later runs really return only new postings. Off (default): return every matching job.

## `stateName` (type: `string`):

Optional name for this search's memory when `onlyNewSinceLastRun` is on, e.g. `python-bangalore-daily`. Leave empty to derive it from the keywords, cities and filters. Use a new name to start over.

## `skipJobIds` (type: `array`):

Array of job IDs you already have (the `id` field from earlier runs), e.g. `["424473", "441980"]`. They are skipped before any page fetch and never charged. Large arrays are fine.

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

Optional, none by default. Instahyre's JSON API and job pages answer Apify's datacenter IPs directly, so no proxy is needed; set one only if your own network policy requires it.

## Actor input object example

```json
{
  "queries": [
    "python"
  ],
  "locations": [],
  "companySizes": [],
  "jobType": "all",
  "companies": [],
  "includeDescription": true,
  "maxJobsPerQuery": 50,
  "maxJobs": 0,
  "onlyNewSinceLastRun": false,
  "skipJobIds": []
}
```

# Actor output Schema

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

Jobs as JSON items in the default dataset (also downloadable as CSV, Excel, XML).

## `runSummary` (type: `string`):

RUN-SUMMARY record: keywords, jobs found, new, filtered, skipped (already delivered / skipJobIds) and charged counts.

# 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 = {
    "queries": [
        "python"
    ],
    "locations": [],
    "companySizes": [],
    "companies": [],
    "skipJobIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_daemon/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 = {
    "queries": ["python"],
    "locations": [],
    "companySizes": [],
    "companies": [],
    "skipJobIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("data_daemon/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 '{
  "queries": [
    "python"
  ],
  "locations": [],
  "companySizes": [],
  "companies": [],
  "skipJobIds": []
}' |
apify call data_daemon/instahyre-jobs-scraper --silent --output-dataset

```

## MCP server setup

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