# Naukri Jobs Scraper — 21 Fields, 7 Filters, New-Job Monitor (`themineworks/naukri-jobs`) Actor

Scrape Naukri.com jobs at scale: title, company, salary (normalised to lakhs), experience, skills, location, remote or hybrid work mode. India residential proxy, no login, pay per job. Works in Claude, ChatGPT & any MCP AI agent.

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

## Pricing

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

## 💼 Naukri Job Scraper: India Jobs, Salary & Skills Data API

> **Part of the Recruiting & Jobs MCP.** This actor's data is also available to AI agents through our [Recruiting & Jobs MCP server](https://apify.com/themineworks/recruiting-jobs-mcp) — seven job-market and sourcing tools behind one endpoint. No result, no charge.

### Overview

Naukri Job Scraper turns any Naukri.com search into structured jobs data. Feed it keywords like `python developer` or `data scientist`, filter by city, salary band, experience, work mode, and industry, and get clean JSON rows with title, company, salary (normalised to lakhs), skills, location, and posting date. No login, no cookies, and India residential proxy is used by default so results match what a real jobseeker in Bangalore would see.

It's the fastest way to build a live labour-market dataset for India: track compensation benchmarks, monitor competitor hiring, source candidates, or feed a jobs board without dealing with Naukri's front-end HTML.

✅ No login required | ✅ India residential proxy | ✅ Pay per job returned | ✅ MCP-ready for AI agents

### Features

Keyword & location search. Query any role in any Indian city or all India at once.
Salary normalisation. Salaries parsed to numeric lakhs for direct filtering and comparison.
Experience & work-mode filters. Filter by minimum and maximum years, remote, hybrid, or work from office.
Rich skills data. Tagged skills, industry, functional area, and role category as arrays.
Deep pagination. Naukri's paginated results are followed to the end within your `maxJobs` budget.

### How it works

The actor issues Naukri search requests directly and parses the same structured payload the Naukri front-end uses. Each keyword you supply is searched separately and results are merged and deduplicated by internal job ID. Filters (location, experience, salary, work mode, job type) are appended to the query as facets so Naukri does the filtering server-side, which is faster and more accurate than post-filtering scraped HTML.

Salary strings ("6-12 Lacs P.A.") are parsed to numeric fields (`salary_min_lakhs`, `salary_max_lakhs`) so you can sort and filter by compensation in downstream tools. Every request runs through an India residential proxy pool so results match what a real user in India would see.

### 🧾 Input configuration

```json
{
  "searchKeywords": ["python developer", "data scientist"],
  "location": "Bangalore",
  "experienceMinYears": 3,
  "experienceMaxYears": 8,
  "salaryMinLakhs": 15,
  "workMode": "hybrid",
  "maxJobs": 200
}
```

### 📤 Output format

```json
{
  "job_id": "310725007833",
  "title": "Senior Python Developer",
  "company": "Acme Analytics",
  "location": "Bengaluru",
  "experience_min_years": 4,
  "experience_max_years": 8,
  "experience_text": "4-8 Yrs",
  "salary_min_lakhs": 15,
  "salary_max_lakhs": 25,
  "salary_text": "15-25 Lacs P.A.",
  "skills": ["Python", "Django", "AWS", "PostgreSQL"],
  "work_mode": "Hybrid",
  "job_type": "Permanent",
  "posted_date_text": "3 Days Ago",
  "posted_days_ago": 3,
  "apply_url": "https://www.naukri.com/job-listings-...-310725007833"
}
```

Every job record contains these fields:

| Field | Description |
| --- | --- |
| 🆔 `job_id` | Naukri internal job ID |
| 📌 `title` | Job title |
| 🏢 `company` | Company name |
| 📍 `location` | Job location(s) as listed on Naukri |
| ⌛ `experience_min_years` | Minimum years of experience required |
| ⏳ `experience_max_years` | Maximum years of experience required |
| 💰 `salary_min_lakhs` | Minimum salary in INR lakhs (numeric) |
| 💵 `salary_max_lakhs` | Maximum salary in INR lakhs (numeric) |
| 🛠️ `skills` | Tagged skills as an array |
| 🏠 `work_mode` | Work from office, remote, or hybrid |
| 📃 `job_type` | Permanent, contract, freelance, temporary, internship |
| 🗓️ `posted_date_text` | Raw posted-date text from Naukri (e.g. "3 Days Ago") |
| 📆 `posted_days_ago` | Approximate days since the job was posted (numeric) |
| 🔗 `apply_url` | URL to the Naukri job detail / apply page |

**One more row at the end of every run:** every run also ends with a final `_type: "info"` record — informational only, never billed — with a two-line nudge: how to put this actor on an automatic schedule (see "Run on a schedule" below), and a link to leave a Store review if it saved you time.

### 💼 Common use cases

**Compensation benchmarking**
Pull every senior Python role in Bangalore and compute median and P90 salary by experience band.
Compare pay across cities, industries, or company sizes for a specific role.

**Competitor hiring intelligence**
Track how many roles a competitor has open, in which functions, and how quickly they close.
Detect new market entries, team expansions, or product bets from job title changes.

**Talent sourcing**
Feed roles into an ATS or sourcing tool to prospect candidates against active reqs.
Build a jobs digest for a specific niche (fintech backend, GenAI, product design).

**Jobs board & marketplace**
Power a niche jobs site with fresh listings pulled by keyword or industry every day.
Enrich existing job feeds with normalised salary and skill data.

### 🚀 Getting started

1. Open the actor and add one or more search keywords (`python developer`, `data scientist`).
2. Set a location (`Bangalore`, `Mumbai`, `Delhi NCR`) or leave blank for all India.
3. Optionally add experience, salary, work-mode, and job-type filters.
4. Set max jobs to return.
5. Click Start. Download as JSON, CSV, or Excel, or pull the dataset via API or MCP.

### 🔁 Run on a schedule

Turn this from a one-off pull into a standing feed with Apify's built-in Schedules — no code, no cron server of your own.

1. Run the actor once with the input you want repeated, then click **Save as a task** (top of the run form) — this keeps your exact input attached for every future run.
2. In the Apify Console, go to **Schedules** (left sidebar) → **Create new**.
3. Name it, set your timezone, and pick a frequency — a preset (hourly / daily / weekly) or a custom cron expression (e.g. `0 6 * * *` for daily at 6am).
4. Under **Actors or tasks to run**, add the task you saved in step 1.
5. Save. From then on it runs unattended on your schedule, billed the same pay-per-job way as a manual run — nothing is charged just for the schedule existing.

Prefer to automate the setup itself? Same thing via the API:

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "naukri-jobs-daily",
    "cronExpression": "0 6 * * *",
    "isEnabled": true,
    "actions": [{ "type": "RUN_ACTOR", "actorId": "themineworks/naukri-jobs" }]
  }'
```

Full options — time zones, run notifications, pausing a schedule — are in Apify's [Schedules documentation](https://docs.apify.com/platform/schedules).

#### Monitor mode — pay only for NEW jobs

Set `monitorMode: true` and this actor remembers what it delivered last time (keyed on
`job_id`) — on the next scheduled run, only genuinely new jobs are pushed and charged.
Re-running the same input daily costs you for the new jobs each day, not the whole feed
every time.

```json
{ "monitorMode": true }
```

Pairs directly with **Run on a schedule** above: save a task with `monitorMode: true`,
attach it to a daily schedule, and you have a standing "what's new" feed with no
duplicate charges. The summary row reports `new_this_run` and `skipped_duplicates` so
you can see the dedup working. First run establishes the baseline (everything is "new");
every run after that is incremental.

### FAQ

**Does it log in to Naukri?**
No. The actor works from public search endpoints only. No account, no cookies, no captcha, no ban risk.

**Why are salaries in lakhs?**
Naukri publishes almost every Indian salary in "lacs per annum". The actor parses that string into numeric `salary_min_lakhs` and `salary_max_lakhs` fields so you can sort, filter, and aggregate compensation directly.

**How do I get more than one page of results?**
Set `maxJobs` to whatever budget you want. The actor follows Naukri's paginated result set until the budget is reached or Naukri runs out of listings for the query.

**Can I use it in an AI agent?**
Yes. It's exposed as an MCP tool. See below.

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

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

Or call it programmatically with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/naukri-jobs').call({
  searchKeywords: ['python developer'],
  location: 'Bangalore',
  maxJobs: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 🛠️ Complete your hiring intelligence pipeline

Found the roles. Now enrich and act on them with the rest of the suite:

- **[LinkedIn Company Scraper](https://apify.com/themineworks/linkedin-company-details)**: profile the hiring company: size, industry, HQ.
- **[LinkedIn Employees Scraper](https://apify.com/themineworks/linkedin-employees)**: find the recruiters and hiring managers at any of the companies.
- **[B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder)**: turn a target company list into named contacts for outreach.

Typical flow: naukri-jobs surfaces the roles, linkedin-company-details profiles the employer, linkedin-employees finds the hiring team.

Questions or need a custom field set? Reach out through the Apify profile.

# Actor input Schema

## `searchKeywords` (type: `array`):

One or more job-search keywords. Each keyword is searched separately and results are merged.

## `location` (type: `string`):

City or region, e.g. 'Bangalore', 'Mumbai', 'Delhi NCR'. Leave blank for all India.

## `experienceMinYears` (type: `integer`):

Minimum years of experience. 0 = fresher.

## `experienceMaxYears` (type: `integer`):

Maximum years of experience.

## `salaryMinLakhs` (type: `integer`):

Minimum annual CTC in INR Lakhs. Naukri supports 3, 6, 10, 15, 25, 50, 75, 100.

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

Employment type.

## `workMode` (type: `string`):

Where the work happens.

## `postedWithinDays` (type: `string`):

Only show jobs posted within the last N days.

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

Maximum number of jobs to scrape across all keywords. Hard cap 1000.

## `includeJobDescription` (type: `boolean`):

If true, include the full job description text. If false, descriptions are truncated to 500 characters.

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

Run on a schedule and deliver ONLY results not seen in a previous run. You are charged per new result, not for the whole feed each time. Ideal for daily monitoring. Requires the same input across runs.

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

Apify proxy. Naukri blocks non-Indian IPs — RESIDENTIAL with IN country code is REQUIRED for >90% success rate.

## Actor input object example

```json
{
  "searchKeywords": [
    "python developer",
    "data scientist"
  ],
  "location": "Bangalore",
  "maxJobs": 5,
  "includeJobDescription": false,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# 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 = {
    "searchKeywords": [
        "python developer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/naukri-jobs").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 = { "searchKeywords": ["python developer"] }

# Run the Actor and wait for it to finish
run = client.actor("themineworks/naukri-jobs").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 '{
  "searchKeywords": [
    "python developer"
  ]
}' |
apify call themineworks/naukri-jobs --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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