# Naukri Jobs Scraper: Salaries, Skills & New Job Alerts (`moggedhq/naukri-jobs-scraper`) Actor

Get Naukri jobs for keywords and cities, such as Python in Bengaluru or sales in Mumbai: salaries, experience, skills, company rating and work mode. Track new India jobs daily with a watch ID. About $0.00034 per job; 1,000 cost $0.34. Full details included. No login.

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

## Pricing

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

## Naukri Jobs Scraper: Salaries, Skills & New Job Alerts

For recruitment teams, staffing agencies, hiring-market analysts and job-board operators who need repeatable Naukri jobs data from India. Search keywords and cities, export salary and experience ranges, collect skills and company ratings, and keep a daily feed of previously unseen job IDs.

About **$0.00034 per delivered job**. A 1,000-job export costs $0.34, plus the small run-start fee. Full job details use the same job price. No Naukri login, account cookies, external API subscription or API key is needed.

### What you get

Each delivered job is one dataset row. A readable summary comes first, followed by the job title, company, locations, salary disclosure, experience, skills and public posting information. Turn on `includeDetails` for full job descriptions, education, department, industry, employment type and applicant counts where Naukri supplies them.

An additional free `SUMMARY` row gives the number of jobs, number newly observed by the selected watch, top companies and the spread of disclosed salaries. A copy is available as the `SUMMARY` record in the run's default key-value store. Free `NOTE` rows explain invalid URLs, expired jobs, missing details or source refusals.

This Naukri scraper exports public jobs and company information. It removes contact sections from descriptions and excludes recruiter contact fields, job-seeker profiles, resumes and applications.

### Start in three steps

1. Enter one or more `keywords`, such as `software engineer`, `accountant` or `nurse`, and optional `locations`, such as `Bengaluru`, `Mumbai` or `Chennai`.
2. Choose `maxItems`. The form prefill requests 20 software-engineering jobs in Bengaluru. Leave details off for the fastest preview, or turn them on for the full posting.
3. Start the run. Open the Jobs overview or Job details dataset view, then download JSON, CSV or Excel. Filter `recordType` to `JOB` when loading job rows into another system.

Cloud validation on 29 October 2026 returned 20 jobs in 20 seconds and 20 detailed jobs in 26 seconds. A paginated 100-job run finished in 52 seconds. Timing includes container startup and varies with source and proxy response times.

### Input reference

| Input | Type | Meaning |
| --- | --- | --- |
| `keywords` | array of strings | Role names, skills or other search terms. Each keyword is searched in each requested city. |
| `locations` | array of strings | Indian cities. Empty means a national search. Bengaluru/Bangalore and Gurugram/Gurgaon are treated as aliases when checking locations. |
| `experienceYears` | number | Keep jobs whose published experience range contains this number of years. Missing ranges do not pass this filter. |
| `salaryMinLakh` | number | Minimum advertised annual salary in lakh INR. A value of `5` means the advertised lower bound must be at least INR 500,000. Hidden salaries are excluded. |
| `workMode` | string | `any`, `office`, `remote` or `hybrid`. Office filtering reads details to verify the mode. |
| `postedWithinDays` | integer | Maximum posting age in days, checked against the source timestamp. |
| `companies` | array of strings | Case-insensitive company-name filters, such as `Infosys`. This narrows search results; it is not an exhaustive company-directory crawl. |
| `startUrls` | array | Optional Naukri search or individual job URLs. Accepts URL strings and objects containing a `url` field. |
| `maxItems` | integer | Global maximum unique delivered jobs across all inputs, up to 10,000. The form prefill is 20; the runtime default is 100. |
| `includeDetails` | boolean | Add the full posting fields. Default `false`. No additional detail event is charged. |
| `onlyNewSinceLastRun` | boolean | Skip IDs delivered by earlier runs of the same watch. Requires `watchId`. Default `false`. |
| `watchId` | string | A persistent watch name. Use a different name for a separate monitoring workflow. |
| `proxyConfiguration` | object | Optional Apify proxy configuration. Default is datacenter, with India residential as the final retry. Set `useApifyProxy: false` for direct HTTP. |

The limits apply across the union of all queries. Earlier inputs have priority when they fill the global cap. Search matches are deduplicated by Naukri job ID before delivery and charging. A job returned by two keywords or repeated URLs produces one job row.

#### Salary and experience research

```json
{
  "keywords": ["accountant"],
  "locations": ["Mumbai"],
  "experienceYears": 3,
  "salaryMinLakh": 2,
  "maxItems": 50,
  "includeDetails": true
}
```

A strict combination can return fewer than `maxItems`. The Actor does not relax salary, experience, work-mode or city filters to fill a quota. It reports how many candidates were inspected and excluded in the summary.

#### Search and individual-job URLs

```json
{
  "startUrls": [
    "https://www.naukri.com/python-jobs-in-bangalore",
    {"url": "https://www.naukri.com/jobs?keyword=sales&location=Mumbai"}
  ],
  "maxItems": 40
}
```

Individual `job-listings-...-<12-digit ID>` URLs are supported too. Direct-job inputs read the full job record, even when `includeDetails` is off. Keywords and URL inputs can be combined. Only HTTPS URLs on Naukri's main or mobile web host are accepted; other domains become free notes.

### Output fields

| Field | Meaning |
| --- | --- |
| `recordType` | `JOB`, `NOTE` or `SUMMARY`. |
| `summary` | A short readable job or run summary. |
| `jobId` | Naukri's job identifier, preserved as a string. |
| `title` | Public job title. |
| `company`, `companyId` | Employer or staffing company shown by Naukri and its public identifier. |
| `companyRating`, `companyReviewCount` | Aggregate AmbitionBox company information embedded in Naukri's response, when present. |
| `locations` | Published cities or location labels. A listing can have several. |
| `workMode` | `office`, `remote`, `hybrid`, or `null` when the source does not identify it. |
| `experienceMin`, `experienceMax` | Published experience range in years. |
| `salaryMin`, `salaryMax` | Numeric annual salary in INR, when disclosed. These are rupees, not lakh units. |
| `salaryCurrency` | Currency supplied by the source, usually `INR`. |
| `salaryDisclosed` | Whether a usable public salary is disclosed; unknown remains `null`. |
| `skills` | Unique published skill labels. |
| `postedAt` | ISO UTC timestamp from Naukri's posting date. |
| `postedAgoText` | Source text such as `1 Day Ago`, when supplied by search. |
| `applicants` | Public apply count from details, when shown. |
| `isNewSinceLastRun` | Whether this ID was absent from this watch's prior delivered IDs. Without a watch, rows are new to this run. |
| `description` | Full plain-text description with contact sections removed, when details are fetched. |
| `education` | Undergraduate, postgraduate and doctorate requirements from details. |
| `industry`, `department` | Public industry and functional area. |
| `roleCategory`, `employmentType` | Published role grouping and employment type. |
| `url`, `applyUrl` | Public job page and application route. The job page is used when no separate supported application URL is supplied. |
| `scrapedAt` | UTC timestamp fixed at run startup for a consistent snapshot. |
| `detailStatus` | `complete`, `not_requested` or `unavailable`. |

Unknown fields stay `null`; missing salaries are never converted to a zero salary. Company ratings describe the employer. Applicant counts can change during a run; use `postedAt` for time comparisons.

#### Real listing example

A software-engineering search in the 29 October 2026 cloud tests returned this job. The sample below selects core fields from the actual result; production rows contain the full schema above.

```json
{
  "recordType": "JOB",
  "jobId": "271026030758",
  "title": "XR- Software Engineer",
  "company": "Qualcomm",
  "locations": ["Bengaluru"],
  "experienceMin": 0,
  "experienceMax": 3,
  "salaryMin": 2000000,
  "salaryMax": 3500000,
  "salaryCurrency": "INR",
  "salaryDisclosed": true,
  "companyRating": 3.6,
  "isNewSinceLastRun": true
}
```

This is a historical example, not a promise that the same listing remains active or has the same counts on a later run.

### Monitor new Naukri jobs every day

Use a stable watch name and keep its search inputs consistent:

```json
{
  "keywords": ["python developer"],
  "locations": ["Bengaluru"],
  "postedWithinDays": 7,
  "onlyNewSinceLastRun": true,
  "watchId": "bengaluru-python-daily",
  "maxItems": 100,
  "includeDetails": true
}
```

The first run delivers its initial set and records those IDs. Later runs use newest-first ordering and skip IDs already delivered by this watch. Only newly delivered jobs incur the job charge. A quiet run can have zero job rows and a free summary, with only the platform's small start fee.

Save the input as an Apify task, create a daily schedule in the Console, and choose that task. Start once a day, then send the dataset to Sheets, a database, Make, Zapier or n8n through your existing Apify integration or webhook. The Actor itself does not send messages.

History is stored in a named key-value store scoped to this Actor, your Apify user and `watchId`. Use distinct watch names for independent searches. Do not overlap runs for the same watch; a short-lived guard rejects an already active watch. Change `watchId` to start a fresh baseline. Job IDs are the comparison unit: edits to an existing posting do not make it a new job.

The scan is bounded to avoid endlessly searching for a rare match: up to ten times `maxItems`, with a minimum of 200 candidates and a maximum of 10,000. Search pagination also stops at 100 pages per query. A daily watch is a recent feed, not an exhaustive change-history or expired-job tracker. Narrow searches can be monitored more completely than a national all-jobs query.

### Price and spending limits

| Delivered jobs | Job price before plan discounts |
| ---: | ---: |
| 20 | $0.0068 |
| 100 | $0.034 |
| 1,000 | $0.34 |
| 10,000 | $3.40 |

The start fee is $0.001 per memory GB, with a minimum of one unit. The normal HTTP run uses 512 MB, so one start unit applies. Bronze has 5% off the job price, Silver 10%, and Gold 20%; the Console displays your applicable price. Full details are included in the same job price.

Only unique delivered job rows are charged. Duplicate matches, rejected filters, previously seen watch IDs, expired job responses, missing sources, retries, notes and summary rows have no job charge. The Actor checks the remaining maximum charge before delivering the next row and stops cleanly when there is no room. A saved row is reconciled with platform event counts after a reboot so it is not delivered or charged twice.

### Use through the API

Use your Apify token as an environment variable. This token authenticates to Apify; it is not a Naukri login. Keep it out of public input examples and shared files.

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/moggedhq~naukri-jobs-scraper/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["data analyst"],"locations":["Pune"],"maxItems":20}'
```

For larger jobs, start asynchronously with `/runs`, poll the run, then download `defaultDatasetId`. Import `jobId` as text to preserve leading zeroes.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("moggedhq/naukri-jobs-scraper").call(run_input={
    "keywords": ["accountant"],
    "locations": ["Mumbai"],
    "maxItems": 20,
    "includeDetails": True,
})
jobs = [row for row in client.dataset(run["defaultDatasetId"]).iterate_items()
        if row.get("recordType") == "JOB"]
```

### Use with AI agents (MCP)

Connect your agent to `https://mcp.apify.com`, add this Actor by its identifier, and ask for a concrete export: "Get 20 Naukri Python jobs in Bengaluru with salary disclosure, skills and company rating." The agent should pass `keywords`, `locations` and `maxItems`, then retrieve the resulting dataset.

For recurring work, ask the agent to reuse the same `watchId` and `onlyNewSinceLastRun: true`. Request details only when the full posting is needed. Tell the agent to read the run summary and free notes before treating an empty dataset as proof that no jobs exist. Source refusals and a quiet watch have different summary statuses.

### Limits and source behavior

- This Actor covers Naukri.com India. Naukrigulf is not included.
- Search is the source's relevance search, not an exact phrase index. Results and ordering can change during pagination.
- Listing-only responses do not always identify office work mode. An unspecified mode remains null. A work-mode filter excludes unverified values.
- Salary filtering is strict and uses disclosed advertised lower bounds. It does not estimate compensation or infer hidden salaries.
- Source posting timestamps can reflect refreshed listings. Daily newness is based on a previously unseen ID, not a guarantee that a vacancy was first created today.
- Full descriptions omit contact sections. Some source postings are short, incomplete or no longer active.
- Individual source failures are free notes and do not remove other successful rows. Check `detailStatus` and the summary for partial results.
- No account login, account cookies, CAPTCHA solving, challenge service or external paid data provider is used. The Actor reads Naukri's public signed-out mobile data interface.
- Naukri's terms restrict scraping and automated access. Review the current source terms and obtain any permission required for your use. This Actor is independent and is not affiliated with Naukri or Info Edge.

### FAQ

#### Is this an official Naukri API?

No. It is an independent export tool that reads public Naukri jobs and returns a stable dataset schema through Apify. There is no Naukri developer credential to configure.

#### Why are there fewer jobs than maxItems?

A filter may exclude candidates, a posting may expire, the source may return fewer matches, a watch may already have seen the IDs, the scan cap may be reached, or your spending limit may stop the run. Read the free summary and notes.

#### Does includeDetails cost more per job?

No. It adds requests and run time, but the job event price is the same. A failed enrichment retains a listing with `detailStatus: unavailable`; it does not invent a description or create an extra detail charge.

#### Can I monitor several cities together?

Yes. Supply several locations. Each keyword is searched in each city until the global result cap is reached. Use separate scheduled tasks when each city must receive its own independent quota.

#### Does the daily mode report edits or expired vacancies?

No. It reports IDs that this watch has not delivered before. Existing IDs remain seen even if their content changes or they disappear from the current results.

#### What happens after an Actor reboot?

The run reloads its saved search-page snapshot and existing dataset, reconciles saved rows with authoritative job-charge counts, and skips completed IDs. It continues until the requested cap or spending limit is reached.

#### Can I get recruiter contact lists?

No. The output focuses on public jobs and companies. Recruiter names, personal contact fields, emails, phone numbers and job-seeker information are outside this Actor's output.

Naukri jobs, Naukri scraper and India jobs exports for repeatable hiring research and daily monitoring.

# Actor input Schema

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

Job titles or skills, for example software engineer, accountant or nurse. Each keyword is searched in each requested city.

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

Indian cities such as Bengaluru, Mumbai, Delhi, Hyderabad or Chennai. Empty searches across India.

## `experienceYears` (type: `number`):

Keep jobs whose advertised experience range contains this number, from 0 to 40.

## `salaryMinLakh` (type: `number`):

Keep only disclosed salaries with an advertised minimum at least this many lakh INR per year. Hidden salaries are excluded.

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

Any, office, remote or hybrid. Office filtering fetches details to verify the mode; unavailable modes are excluded.

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

Keep jobs posted within this many days, based on the public posting timestamp.

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

Optional case-insensitive name filter. Narrows returned rows; does not crawl every company page.

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

Optional Naukri HTTPS job or search URLs, as strings or objects with a url field. Examples: https://www.naukri.com/python-jobs-in-bangalore and https://www.naukri.com/jobs?keyword=accountant\&location=Mumbai.

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

Global cap on unique delivered jobs across all inputs. Notes and summary records are free. Up to 10,000.

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

Add full descriptions, education, industry, department, employment type, applicants and verified work mode where available. Same job price.

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

With a watchId, save only IDs not delivered by an earlier run. First run returns its initial baseline. Keep inputs stable and avoid overlapping runs.

## `watchId` (type: `string`):

Name for persistent seen-job history, for example bengaluru-python-daily. Required for only-new mode. Use different names for independent searches.

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

Default uses Apify datacenter, with India residential after repeated refusals. For direct HTTP set useApifyProxy to false.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "Bengaluru"
  ],
  "workMode": "any",
  "maxItems": 20,
  "includeDetails": false,
  "onlyNewSinceLastRun": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "keywords": [
        "software engineer"
    ],
    "locations": [
        "Bengaluru"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/naukri-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 = {
    "keywords": ["software engineer"],
    "locations": ["Bengaluru"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/naukri-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 '{
  "keywords": [
    "software engineer"
  ],
  "locations": [
    "Bengaluru"
  ],
  "maxItems": 20
}' |
apify call moggedhq/naukri-jobs-scraper --silent --output-dataset

```

## MCP server setup

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