# Instahyre Jobs Scraper (`nanoscrape/instahyre-jobs-scraper`) Actor

Scrape tech job listings from Instahyre, the Indian hiring platform. Title, company profile, locations, skill tags and job link per job, with search by skill and location. Pay-per-result.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Get the public job listings of Instahyre, an Indian hiring platform for tech roles, as one clean dataset. Search by skill and city and get one row per job with the title, the skill tags, the locations and the full public company profile. No login needed.

### What you can do with it

- Build a daily feed of new tech jobs in India per skill, for example Python, React or DevOps.
- See which companies hire for a skill in Bangalore, Pune, Hyderabad or Gurgaon, with company size band, founding year and a short description.
- Compare the demand for skills across cities by counting jobs per keyword and location.
- Find hiring companies for lead lists and recruiting research, with logo, tagline and description.
- Feed job boards, market reports or alerts with structured data instead of web pages.

### What you get

One row per job. Fields that a job does not carry are `null`, lists are always `[]` when empty.

| Field | What it holds |
|---|---|
| `id`, `job_id` | Row id (`instahyre-<job id>`) and Instahyre's own job id |
| `title` | Job title |
| `company`, `company_id` | Name and Instahyre id of the hiring company |
| `company_tagline`, `company_description`, `company_description_short` | The company's tagline and the descriptions Instahyre shows for it (the short one is `null` when Instahyre gives none) |
| `company_founded`, `company_employee_count` | Founding year and company size as Instahyre publishes it: a size band value such as 1, 10, 50, 200, 500 or 1000, not an exact head count |
| `company_logo_url` | Link to the company logo |
| `company_featured`, `company_diversity_employer` | Whether Instahyre marks the company as a featured or diversity employer |
| `locations`, `location` | Job locations as a list and joined as text, for example `["Bangalore", "Pune"]` and `Bangalore, Pune`. `Work From Home` appears as a location name |
| `keywords` | Skill and keyword tags of the job |
| `accept_outstation` | Whether the employer accepts candidates from outside the job city |
| `job_url` | Link to the public job page on Instahyre |
| `source_query`, `source_location`, `scraped_at` | The skill and location of the search that found the job (empty when the search had none) and the collection time |

Every job appears once per run, even when several searches or pages find it.

There is no full job description, salary or posting date in the data: Instahyre does not publish them in its public job list, so this actor does not return them. Use `job_url` to read the full posting on Instahyre.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | string list | Skills or keywords such as `python`, `react` or `devops`. Each one runs as its own search; a keyword with commas is split into one search per part. Empty means all jobs |
| `location` | string list | Optional cities such as `Bangalore` or `Pune`. Each location runs with every keyword |
| `strictLocation` | boolean | Default `true`: keep only jobs where one of `locations` contains the location text (Bangalore also matches Bengaluru, Gurgaon matches Gurugram, Mumbai matches Bombay). Jobs filtered out are never charged. `false` keeps everything Instahyre returns for the search, including jobs for other cities |
| `maxResults` | integer | Total number of jobs over everything. Default `100`, `0` means no limit |
| `maxResultsPerQuery` | integer | Jobs per keyword and location. Default `100`, `0` means no limit |

#### Example: Python jobs in Bangalore

```json
{
  "searchQueries": ["python"],
  "location": ["Bangalore"],
  "maxResults": 200,
  "maxResultsPerQuery": 200
}
```

#### Example: several skills, two cities

```json
{
  "searchQueries": ["react", "devops", "data engineer"],
  "location": ["Pune", "Hyderabad"],
  "maxResults": 0,
  "maxResultsPerQuery": 100
}
```

#### Example: all jobs

```json
{
  "maxResults": 500
}
```

### Output

```json
{
  "id": "instahyre-447614",
  "job_id": "447614",
  "title": "Python Developer",
  "company": "TopDoc",
  "company_id": "50756",
  "company_tagline": "A leading technology-enabled healthcare platform",
  "company_description": "TopDoc is a US-based healthcare platform that simplifies the patient experience.",
  "company_description_short": null,
  "company_founded": 2000,
  "company_employee_count": 1,
  "company_logo_url": "https://media.instahyre.com/images/profile/base/employer/50756/logo.webp",
  "company_featured": false,
  "company_diversity_employer": false,
  "locations": ["Bangalore"],
  "location": "Bangalore",
  "keywords": ["Backend", "FastAPI", "Python"],
  "accept_outstation": true,
  "job_url": "https://www.instahyre.com/job-447614-python-developer-at-topdoc-bangalore/",
  "source_query": "python",
  "source_location": "",
  "scraped_at": "2026-11-04T09:00:00Z"
}
```

The example is shortened and the values are illustrative.

### Pricing

Pay per result, two events:

- `apify-actor-start`: $0.001 once per run.
- `job-result`: $0.0008 per job in the dataset ($0.80 per 1,000 jobs).

Duplicate jobs are never charged. Set a maximum total charge on the run to stop at a budget; the run then ends cleanly with the message "Stopped at the max charge limit. N jobs delivered." The pricing box on the actor page always shows the current rates.

### Use with AI Agents (MCP)

Connect this actor to any MCP-compatible AI client, such as Claude Desktop, Claude.ai, Cursor, VS Code, LangChain, LlamaIndex, or custom agents.

**Example prompts once connected:**

> "Use `instahyre-jobs-scraper` to find Python jobs in Bangalore and list the company, skills and company size."

> "Use `instahyre-jobs-scraper` for react, devops and golang in Pune and count the jobs per skill."

Configure the MCP server with the Instahyre Jobs Scraper preconfigured at `mcp.apify.com?tools=nanoscrape/instahyre-jobs-scraper`:

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

See the auto-generated API tab on the actor page for language-specific examples (cURL, JavaScript, Python, and more).

### FAQ

**What does one run cost?**
A start fee plus one result fee per job in the dataset. Use `maxResults` or a maximum total charge to cap it.

**Does it return the full job description or the salary?**
No. Instahyre does not publish a description, salary or posting date in its public job list, so each row has the title, skills, locations and company profile. `job_url` links to the full posting.

**Why do I see jobs from other cities when I set a location?**
Instahyre uses the location to rank jobs, so other cities can follow. With `strictLocation` on (the default) those jobs are dropped before they are charged. Turn it off to keep them and use `locations` and `accept_outstation` to decide yourself.

**Why is `company_employee_count` not an exact number?**
Instahyre publishes the company size as a band value (1, 10, 50, 200, 500, 1000), not a head count.

**What if a search finds nothing?**
The run ends successfully with the message "0 jobs." and the reason, for example no hits for the keyword.

**Can I get only new jobs?**
The job list carries no posting date, so the actor cannot filter by date. Run it on a schedule and compare `job_id` values with the previous run.

### Limits

- Jobs are read 35 per page, one page at a time with a short pause, so very large runs take a while.
- Instahyre lets a search read only its first 10,000 jobs. When a search has more, the run still succeeds and the status message says "first 10,000 of N jobs; narrow the search with keywords or location". Use keywords and locations to split larger searches.
- Only public listing data is returned.
- You are responsible for using the data lawfully, including data-protection laws and unfair-competition rules for marketing and outreach.

### Support

Questions, feature requests or a field you miss: <contact@nanoscrape.com>.

Built by NanoScrape. Not affiliated with Instahyre.

# Changelog

This Actor's version history is a separate document: https://apify.com/nanoscrape/instahyre-jobs-scraper/changelog.md

# Actor input Schema

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

One or more skills or keywords such as python, react or devops. Each one runs as its own search. Leave empty to list all jobs. Jobs found by several searches are returned once.

## `location` (type: `array`):

Optional cities such as Bangalore, Pune or Hyderabad. Each location runs with every keyword. Instahyre ranks jobs for that city first but also returns jobs for other cities; with Strict Location on, only jobs listed in that city are kept.

## `strictLocation` (type: `boolean`):

On (default): keep only jobs where one of the job's locations contains the location text, so Bangalore also matches Bengaluru, Gurgaon matches Gurugram and Mumbai matches Bombay. Jobs filtered out are never charged. Off: keep everything Instahyre returns for the search, including jobs for other cities.

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

Maximum number of jobs in total over all searches. 0 = no limit.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of jobs per keyword and location. 0 = no limit.

## Actor input object example

```json
{
  "searchQueries": [
    "python"
  ],
  "location": [],
  "strictLocation": true,
  "maxResults": 100,
  "maxResultsPerQuery": 100
}
```

# Actor output Schema

## `jobListings` (type: `string`):

Dataset containing the scraped Instahyre jobs.

# 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"
    ],
    "location": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("nanoscrape/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"],
    "location": [],
}

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

```

## MCP server setup

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