# Instahyre Jobs Scraper - 14 Fields, Monitor Mode, No Login (`themineworks/instahyre-jobs-scraper`) Actor

Scrape Instahyre's public India tech job-search feed — title, company profile, skills and location. No login, no cookies, pay per job. Full job descriptions require an Instahyre account (see Coverage). Use it as an MCP server in Claude, ChatGPT & AI agents.

- **URL**: https://apify.com/themineworks/instahyre-jobs-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Jobs, Lead generation, MCP servers
- **Stats:** 24 total users, 10 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 job scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Instahyre Jobs Scraper: India Tech Job Search Feed

Scrape Instahyre's public India tech job-search feed — title, company profile, skills and location. No login, no cookies, pay per job. Full job descriptions require an Instahyre account (see **Coverage** below — this actor is honest about that boundary rather than pretending around it). Use it as an MCP server in Claude, ChatGPT & AI agents.

> 💸 You are only charged for delivered results — empty searches, failed pages and duplicates are never billed.

### What it does

Instahyre is one of India's larger tech-recruiting platforms, built for both job seekers and employers looking for candidate/hiring signal. Its website is aggressively bot-managed: the homepage, the job-search page and every individual job page sit behind a Cloudflare browser-integrity challenge that returns 403 "Just a moment..." to plain HTTP requests and even to a Googlebot user agent. That looked, at first, like a fully login-walled target.

It isn't. Instahyre's own front-end calls a **public, unauthenticated JSON API** to populate its job-search page — `GET https://www.instahyre.com/api/v1/job_search/` — and that endpoint answers with a clean `200` and zero cookies from a plain datacenter IP, no browser and no challenge-solving required. This actor reads that endpoint directly. It does not touch the HTML site, does not attempt to bypass Cloudflare, and does not use a browser.

This is a real, verified finding, not an assumption: every filter and boundary documented below was tested live against the endpoint before being written into the code.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `jobFunctionSlugs` | array | no | `["backend-development"]` | Instahyre job-function slugs to filter by, e.g. `backend-development`, `full-stack-development`, `data-science-machine-learning`. Resolved to Instahyre's own numeric ids via its public job-function list; unknown slugs are skipped with a warning. Leave empty to walk the unfiltered feed. |
| `jobType` | string | no | `any` | `any`, `full_time`, or `internship`. A real server-side filter. |
| `companySize` | string | no | `any` | `any`, `small`, `medium`, or `large`. A real server-side filter. |
| `maxJobs` | integer | no | `100` | Maximum jobs to return across all pages/functions. Capped at 5000 per run. |
| `monitorMode` | boolean | no | `false` | When on, this and every later scheduled run of the same actor for you delivers only jobs not seen before — built for a daily/hourly schedule. |
| `proxyConfiguration` | object | no | Apify auto | Datacenter is sufficient; Instahyre's JSON API is not behind the Cloudflare challenge that gates its HTML pages. |

#### Example input

```json
{
  "jobFunctionSlugs": ["backend-development"],
  "jobType": "any",
  "companySize": "any",
  "maxJobs": 10
}
```

### Output

One record per job, taken from a real run against the live API.

| Field | Type | Example |
|---|---|---|
| `job_id` | integer | `435844` |
| `title` | string | `"Senior Software Engineer - Backend"` |
| `candidate_title` | string | *(present only when it differs from `title`)* |
| `company_name` | string | `"Paytm"` |
| `company_tagline` | string | `"India's largest mobile payment and commerce platform"` |
| `company_founded` | integer | `2000` |
| `employee_count` | integer | `1000` |
| `company_about` | string | `"Paytm is a platform for an e-commerce marketplace..."` |
| `locations` | array | `["Bangalore"]` |
| `locations_raw` | string | `"Bangalore"` |
| `skills` | array | `["Data Structures", "Golang", "Java", "Node.js", "Hibernate", "J2EE", "Spring"]` |
| `accept_outstation` | boolean | `true` |
| `public_url` | string | `"https://www.instahyre.com/job-435844-senior-software-engineer-backend-at-paytm-bangalore/"` |
| `resource_uri` | string | `"/api/v1/job_search/435844"` |
| `scraped_at` | string | `"2026-07-31T18:22:11.000Z"` |

#### Example output

```json
{
  "job_id": 435844,
  "title": "Senior Software Engineer - Backend",
  "company_name": "Paytm",
  "company_tagline": "India’s largest mobile payment and commerce platform",
  "company_founded": 2000,
  "employee_count": 1000,
  "company_about": "Paytm is a platform for an e-commerce marketplace, mobile recharge, bill payments, peer-to-peer funds transfer, etc. Also operates a payment bank. Investors include Alibaba, SAIF Partners, Mediatek and more.",
  "locations": ["Bangalore"],
  "locations_raw": "Bangalore",
  "skills": ["Data Structures", "Golang", "Java", "Node.js", "Hibernate", "J2EE", "Spring"],
  "accept_outstation": true,
  "public_url": "https://www.instahyre.com/job-435844-senior-software-engineer-backend-at-paytm-bangalore/",
  "resource_uri": "/api/v1/job_search/435844",
  "scraped_at": "2026-07-31T18:22:11.000Z"
}
```

Each run also pushes one non-billable `_type: "market_snapshot"` row built from Instahyre's own live facet counts for your query (total jobs indexed, job-type/company-size/experience-level breakdowns, and top locations/companies/functions) — real numbers straight from the source, useful as a standalone India tech-hiring signal even before you look at individual listings.

### Coverage — what this actor does NOT cover, and why

Be clear-eyed about the boundary. This actor's public surface is Instahyre's job-**search** feed, which returns per-job: title, employer profile, a free-text locations string, a skills/keywords array and the public job URL.

It does **not** return, and cannot return without an Instahyre account:

- **Full job descriptions** — these render only on the individual job page, which sits behind the same Cloudflare browser-integrity challenge as the rest of the HTML site (verified: 403 "Just a moment..." even with a Googlebot user agent).
- **Salary** and **per-job experience range** — not present anywhere in the public API response; these are Instahyre's own aggregate facet stats (total counts across the whole index), not per-listing fields.
- **Candidate-visibility / recruiter-side data** — Instahyre's core recruiter product (searching and viewing candidate profiles) is entirely behind a logged-in dashboard and is out of scope for a public scraper by design; we do not attempt to log in or emulate a recruiter session.
- **Free-text keyword or location search** — plausible-looking parameters (`keywords`, `search`, `q`, `location`, `city`, `experience`) are silently accepted by the API but ignored (verified: identical `total_count` with or without them). Only `job_functions`, `job_type` and `company_size` are genuine server-side filters, confirmed against the API's own facet counts — so those are the only filters this actor exposes. We do not document a capability the code doesn't actually have.
- **Beyond ~10,000 results per filter combination** — Instahyre's own search index caps offset pagination at `offset + 35 <= 10,000` (Elasticsearch's default result window); requesting further returns a server error. Narrow with `jobFunctionSlugs`/`jobType`/`companySize` to reach deeper into a large category.

If your use case needs full descriptions or salary bands, that data genuinely requires an Instahyre account and is not something any public scraper can honestly deliver.

### Use cases

- **India tech hiring-demand tracking** — the `skills` array and job-function facets give a structured read on what's actively being hired for, without NLP over free text.
- **Company hiring-signal monitoring** — track which employers are posting roles in a given function, paired with `employee_count` for company-size segmentation.
- **Recruiter sourcing lists** — filter by function/type/size to build a target list of companies actively hiring in a niche.
- **Market-intelligence snapshots** — the built-in `market_snapshot` row gives top locations, top companies and function/experience-level distribution for free on every run.
- **Scheduled new-postings monitor** — enable `monitorMode` and run this on an Apify schedule to get only newly-posted jobs each time, without re-paying for the whole feed.

### FAQ

#### Is this scraping HTML?

No. It reads the same public JSON endpoint Instahyre's own job-search page calls. No browser, no Cloudflare challenge to solve.

#### Why don't I get salary or a full job description?

Instahyre doesn't publish either in its public search feed. Salary/description only render on the individual job page, which requires passing the same Cloudflare check that blocks a plain scraper from that page entirely. We chose not to build a fragile challenge-solving path around that — see **Coverage**.

#### Can I search by keyword or city?

Not server-side — Instahyre's API silently ignores those parameters. You can filter client-side on the `skills`/`locations` fields in the returned dataset, or use `jobFunctionSlugs` for a genuine server-side narrow.

#### How do I find valid `jobFunctionSlugs` values?

The actor resolves slugs against Instahyre's own live list at `https://www.instahyre.com/api/v1/job_function/` and warns on anything unrecognized, so a typo never fails silently.

### Billing

Pay per event: one `job-scraped` event per delivered record, charged only **after** the record is validated and stored. Empty results, blocked pages and duplicates are never charged. Store discounts apply automatically on paid Apify plans.

### Use in Claude, ChatGPT & any MCP agent

This actor runs as an MCP server, so an AI agent can call it directly:

```
https://mcp.apify.com/?tools=themineworks/instahyre-jobs-scraper
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("themineworks/instahyre-jobs-scraper").call(
    run_input={"jobFunctionSlugs": ["backend-development"], "maxJobs": 10}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Legal and compliance

This actor collects only publicly available information — the same data Instahyre's own job-search page serves to any visitor, via the same public JSON endpoint its front-end calls. It does not access private or authenticated areas, does not attempt to bypass Cloudflare's protections on the site's HTML pages, and collects no personal data beyond what the source already publishes openly. You are responsible for using the output in line with the source site's terms and with the data protection law that applies to you.

MIT © [The Mine Works](https://apify.com/themineworks)

# Actor input Schema

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

Instahyre job-function slugs to filter by, e.g. 'backend-development', 'full-stack-development', 'data-science-machine-learning'. The actor resolves each slug to Instahyre's own numeric job\_functions id via its public https://www.instahyre.com/api/v1/job\_function/ list, so unknown slugs are skipped with a warning rather than silently ignored. Leave empty to walk the unfiltered feed across all functions.

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

Filter by employment type. This is a genuine server-side filter (verified against Instahyre's own facet counts), unlike free-text search which the API silently ignores.

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

Filter by hiring company's size band. A genuine server-side filter (verified against Instahyre's own facet counts).

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

Maximum jobs to return across all pages/functions. Instahyre's own search index has a ~10,000-result pagination ceiling per filter combination (Elasticsearch's default max\_result\_window) — narrow with jobFunctionSlugs/jobType/companySize to reach further into a large category.

## `monitorMode` (type: `boolean`):

When enabled, this and every subsequent scheduled run delivers ONLY jobs not seen in a prior run of this actor for you — ideal for a daily/hourly schedule watching for new postings. Leave off for a normal one-off full pull.

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

Instahyre's job-search JSON API is not behind Cloudflare's browser challenge and answers plain datacenter requests directly (verified live) — residential is not required. Left as Apify's automatic proxy as a buffer against rate limiting at scale.

## Actor input object example

```json
{
  "jobFunctionSlugs": [
    "backend-development"
  ],
  "jobType": "any",
  "companySize": "any",
  "maxJobs": 10,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "jobFunctionSlugs": [
        "backend-development"
    ],
    "maxJobs": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/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 = {
    "jobFunctionSlugs": ["backend-development"],
    "maxJobs": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "jobFunctionSlugs": [
    "backend-development"
  ],
  "maxJobs": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call themineworks/instahyre-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=themineworks/instahyre-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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