# Naukri Job Scraper - India Jobs, INR Salaries, Skills & Ratings (`s-r/naukri-jobs-scraper`) Actor

Search Naukri.com, India's largest job board, by keyword, city or search URL. Get one row per job with company IDs, annual INR salary ranges, experience in years, skills, posting time and the company rating and review count. Built for recruiters, HR tech and labour-market research.

- **URL**: https://apify.com/s-r/naukri-jobs-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Jobs, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job listing returneds

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

## Naukri Job Scraper

Naukri Job Scraper turns Naukri.com job search results into clean, structured rows for recruiters, HR software and India labour-market research. Search by job title, skill, company or city, or paste a Naukri search URL with your own filters, and get one row per unique job listing with annual INR salary ranges, skills, experience in years and the company rating and review count that Naukri shows.

Naukri is India's largest job board, so it is the natural source for hiring demand in Bengaluru, Hyderabad, Pune, Chennai, Mumbai, Delhi NCR and beyond. Use the output to compare hiring demand across cities, monitor employers, group vacancies by skill, benchmark salaries or feed a recruiting workflow. Every row carries Naukri's own job ID, company account ID and employer group ID, so repeated searches are easy to join without matching on company names.

### What the Naukri Job Scraper returns

- **Job identity:** `job_id`, `title`, `url`, `posted_at` (UTC) and the relative label shown on Naukri (`posted_relative`).
- **Company:** `company`, `company_id`, `company_group_id`, company page and logo, and whether the poster is a recruitment consultant.
- **Location and work mode:** the advertised location text, each individual city in `locations`, and `work_mode` (office, remote or hybrid).
- **Experience:** `experience_min_years` and `experience_max_years` as numbers, plus the original label.
- **Salary:** `salary_min` and `salary_max` as annual INR amounts when the employer discloses pay, or `Not disclosed` in `salary_text` when it does not.
- **Skills and description:** the skill tags of the listing and a plain-text description fragment.
- **Company rating:** the AmbitionBox rating and review count that Naukri includes on the search card.

### How to scrape Naukri jobs without code

1. Enter a keyword such as `python developer`, or a city such as `bangalore`. You can supply both.
2. Set `max_items` to the maximum number of unique jobs you want across the run. The default is 100 and the supported range is 1–10,000.
3. Optionally select posting age, candidate experience, work arrangement, employer type or salary bands.
4. Start the actor. Download the dataset as JSON, CSV or Excel, or retrieve it with the Apify API.

For a search you have already configured on Naukri, copy the address bar into `start_urls`. You can provide up to 20 search URLs. Their query parameters are preserved, and their filters take precedence over the separate keyword and filter fields. The maximum row count applies to the entire run, including all supplied URLs. Pagination is automatic: the actor walks through the result pages (20 jobs per page) until it reaches your limit or the end of the search.

### Input

The following input was verified against real Naukri search responses:

```json
{"keyword":"python developer","location":"bangalore","max_items":100}
```

| Field | Meaning |
|---|---|
| `keyword` | Job title, skill or company. Leave empty for a location-only search. |
| `location` | City or comma-separated cities. Leave empty to search all locations. |
| `start_urls` | HTTPS search URLs on `www.naukri.com`, including existing filters and an optional starting page. |
| `max_items` | Maximum unique rows across the run; default 100. |
| `sort` | `relevance` or `date`; applies when building a search from keyword and location. |
| `freshness_days` | Jobs posted within 1, 3, 7, 15 or 30 days. |
| `experience_years` | Candidate experience from 0 to 30 years. Zero includes fresher roles. |
| `work_mode` | A list containing `office`, `remote` and/or `hybrid`. |
| `posted_by` | `company` or `consultant`. Omit to include both. |
| `salary_range` | Naukri bands such as `10to15` or `15to25`, measured in lakh INR per year. |

Provide at least one of keyword, location or a search URL. Direct job detail URLs are not search inputs. A pasted search URL retains its own ordering and filtering, so changing a separate filter does not alter that URL. On Apify, pagination continues automatically; the `cursor` field is intended for API continuation and can be left empty in the actor form.

### Output

Each job contains `job_id`, `title`, `url`, `company`, `location`, `posted_at`, `source`, `platform` and `fetched_at`. Naukri identifiers are delivered as strings, preserving leading zeroes. Posting timestamps are UTC with milliseconds, while `posted_relative` preserves the wording shown on the search card.

The additional fields include company account and group IDs, company links and logos, individual advertised locations, work mode, minimum and maximum experience, skills, a plain-text description fragment, company rating and review count, vacancies and external application links where present. Recruitment agencies are identified with `is_consultant`; an end client appears in `hiring_for` only when Naukri names it. Walk-in listings include their date label without dedicated contact names or phone numbers.

A real job from the recorded `python developer` search in Bangalore on 5 October 2026, with a disclosed salary of 10–22 lakh per year:

```json
{
  "job_id": "051026039668",
  "title": "python developer",
  "url": "https://www.naukri.com/job-listings-python-developer-virtusa-bengaluru-5-to-8-years-051026039668",
  "company": "Virtusa",
  "company_id": "1354",
  "company_group_id": "1186200",
  "location": "Bengaluru",
  "locations": ["Bengaluru"],
  "work_mode": "office",
  "posted_at": "2026-10-05T13:28:29.438Z",
  "posted_relative": "Few Hours Ago",
  "experience_min_years": 5,
  "experience_max_years": 8,
  "experience_text": "5-8 Yrs",
  "salary_text": "10-22 Lacs PA",
  "salary_disclosed": true,
  "salary_min": 1000000,
  "salary_max": 2200000,
  "salary_currency": "INR",
  "salary_period": "YEAR",
  "skills": ["Artificial Intelligence", "Snowflake", "Python", "Intelligence", "Python Development", "Development"],
  "snippet": "Troubleshoot issues related to AI model performance,data quality,and system integration. Job Requirements : . 5-8 years of experience in developing AI applications using Python programming language",
  "company_rating": 3.6,
  "company_reviews_count": 6613,
  "ambitionbox_url": "https://www.ambitionbox.com/reviews/virtusa-consulting-services-reviews",
  "is_consultant": false,
  "is_walk_in": false
}
```

The same search also returned listings whose pay was hidden. For those rows the numeric bounds stay null, for example Infosys job `250926036403` ("Python Developer (5 To 8 Years)", hybrid in Hyderabad, Chennai and Bengaluru) with `salary_text` `Not disclosed`, a 3.5 company rating and 52,758 reviews.

### Salary and description interpretation

Disclosed numeric salaries use `salary_min`, `salary_max`, `salary_currency` and `salary_period`. Annual amounts are in the currency's base units: a disclosed 10–22 lakh INR range becomes 1,000,000–2,200,000 INR with period `YEAR`. A hidden salary has null numeric fields and retains its original `salary_text`, usually `Not disclosed`.

Internship compensation may be advertised as `15,000/month` or `Unpaid`. These labels stay in `salary_text`; they are not converted into annual salary bounds. Missing experience stays null, including internships or walk-ins that have no experience label. Missing company review information also stays null instead of becoming a zero rating.

The `snippet` field is the description fragment supplied on the search page with HTML removed. It can be long for some employers, but it is not promised as the complete job description. The actor does not fill a full-description field from a fragment, infer a contract type, or assign a country merely because most results are in India. Naukri can show several cities or international locations in one listing.

### Search totals and incomplete results

The `searches` key-value record shows each search, its first retrieved URL, the total result count reported by Naukri, successful page count, delivered unique row count and any warning. Totals are snapshots, and listings may change while a large run is in progress. Duplicate job IDs across pages and searches are delivered once, so overlapping searches can return fewer rows than their raw page counts suggest.

A genuine search with no jobs yields an empty dataset and a recorded `not_found` outcome. A blocked or unusable search page is reported as a source error. Earlier collected jobs remain available if a later page fails. Check the run output, errors and search warnings when fewer jobs arrive than requested. An unrecognized city can be ignored by Naukri; if the city cannot be confirmed in its facets, the run includes a warning that results may cover other locations.

### Use cases

- **Recruiting and sourcing:** find which employers are hiring for a skill in a city this week, and which of them are agencies rather than direct employers.
- **Salary benchmarking:** compare disclosed annual INR ranges by role, city and experience band, while keeping undisclosed salaries apart instead of counting them as zero.
- **HR tech and job aggregators:** feed fresh Naukri listings into a job board, alerting tool or applicant matching system, keyed on stable job IDs.
- **Labour-market research:** track the number of open roles per skill, the share of remote and hybrid work, or hiring demand across Indian cities over time.
- **Employer monitoring and sales leads:** follow specific companies through `company_group_id`, and combine hiring volume with their company rating and review count.

### Naukri Job Scraper compared with other options

| | This actor | Naukri API | Browser extensions | Own script |
|---|---|---|---|---|
| Public job search | Yes, keyword, city or URL | Not public; recruiter and employer integrations only | One page at a time | Yes, if you maintain it |
| Annual INR salary as numbers | Yes, hidden pay stays null | n/a | Text only | Your own parsing |
| Skills and company rating | Yes | n/a | Varies | Your own parsing |
| Pagination and de-duplication | Automatic, up to 10,000 jobs per run | n/a | Manual | Your own code |
| Scheduling, API and exports | Apify schedules, API, JSON, CSV, Excel | n/a | Manual download | Your own setup |

Many people search for a "Naukri API" to get job data. Naukri's integrations are meant for recruiters posting and managing their own jobs, not for reading public search results, so this actor is the practical alternative: you call it through the Apify API with the same input as in the form and get JSON back.

Other Naukri scrapers in the Apify Store return the raw fields from the search page. This actor focuses on completeness and clean types: salaries converted to annual INR numbers, experience as numbers, skills as a list, company IDs for joining, and the company rating and review count on every row where Naukri supplies them.

### Pricing

Pay per event, with no monthly fee:

| event | price |
|---|---|
| Actor run started | $0.001 per run |
| Job listing returned | $0.0005 per job |

Some examples:

- 10 jobs: $0.001 + 10 × $0.0005 = **$0.006**
- the default of 100 jobs: $0.001 + 100 × $0.0005 = **$0.051**
- 1,000 jobs: $0.001 + 1,000 × $0.0005 = **$0.501**

You only pay for jobs that are actually delivered. Pagination does not add another start event, and duplicate job IDs are not charged twice. A valid search that finds nothing costs only the run start; invalid input costs nothing. The pricing tab of the actor shows the active amounts.

Users without a paid Apify plan receive at most 10 jobs per run. The actor limits the requested volume before collecting and charges only for delivered rows. Paid users can request the full supported limit. This cap applies to the complete run, including multiple search URLs.

### FAQ

#### Does the Naukri Job Scraper collect full job descriptions?

It returns the search-page fragment as `snippet`. Open the job URL for the complete advertisement. No separate job-detail retrieval is performed.

#### Is there an official Naukri API for job search data?

Naukri offers integrations for recruiters and employers to manage their own postings, not a public API for reading job search results. This actor gives you that data through the Apify API instead, as JSON, CSV or Excel.

#### Are AmbitionBox ratings included for every company?

Only when Naukri includes them. `company_rating`, `company_reviews_count` and `ambitionbox_url` are null when the search response has no company review data.

#### Can I collect more than 100 jobs?

Yes. Increase `max_items` up to 10,000. The actor follows pages automatically and keeps one row per job ID throughout the run. Source exhaustion or a recorded error may end collection before the limit.

#### Why is a salary null even though salary_text contains an amount?

Internship stipends and undisclosed annual pay do not supply reliable annual numeric bounds. The original label is preserved so you can interpret it without mistaking a monthly stipend or hidden salary for zero annual pay.

#### Can I export Naukri jobs to Excel or Google Sheets?

Yes. Every run stores its jobs in an Apify dataset that you can download as Excel, CSV or JSON, or connect to Google Sheets through Apify integrations.

#### Can I join output from different runs?

Use `job_id` to compare jobs and `company_group_id` to group employer brands. `company_id` identifies the particular Naukri account or branch. Keep `fetched_at` and the search metadata alongside snapshots when tracking changes over time.

#### Is it legal to scrape Naukri?

The actor only collects job listings that Naukri shows publicly to every visitor, without logging in, and it does not collect recruiter contact details. You remain responsible for using the data in line with applicable law and Naukri's terms, especially when you store or republish it.

# Actor input Schema

## `keyword` (type: `string`):

Job title, skill or company to search. Provide keyword, location or start_urls.

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

City or comma-separated cities, for example bangalore or pune, mumbai. Omit to search all locations.

## `start_urls` (type: `array`):

Up to 20 HTTPS Naukri search URLs. Their query filters take precedence over the separate search fields.

## `sort` (type: `string`):

Sort a keyword/location search by relevance or posting date. A pasted URL retains its own sorting.

## `freshness_days` (type: `integer`):

Show jobs posted within this many days; applies to keyword/location searches. Allowed values: 1, 3, 7, 15, 30.

## `experience_years` (type: `integer`):

Candidate experience in years, including 0 for freshers.

## `work_mode` (type: `array`):

Work arrangements to include. Omit for all arrangements.

## `posted_by` (type: `string`):

Restrict keyword/location searches to companies or recruitment consultants.

## `salary_range` (type: `array`):

Naukri salary bands in lakh INR per year; 10to15 means 10–15 lakh annually.

## `max_items` (type: `integer`):

Maximum unique jobs over the complete search, including cursor continuation; the Apify actor continues automatically.

## `cursor` (type: `string`):

Signed next_cursor from a previous response. Keep search fields unchanged. The actor handles this automatically.

## Actor input object example

```json
{
  "keyword": "python developer",
  "location": "bangalore",
  "sort": "relevance",
  "max_items": 100
}
```

# Actor output Schema

## `jobs` (type: `string`):

One row per unique job listing.

## `searches` (type: `string`):

Search totals, successful page counts and warnings.

## `summary` (type: `string`):

Delivered jobs, errors and charges.

## `errors` (type: `string`):

Search pages that could not be collected.

# 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 = {
    "keyword": "python developer",
    "location": "bangalore"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {
    "keyword": "python developer",
    "location": "bangalore",
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "keyword": "python developer",
  "location": "bangalore"
}' |
apify call s-r/naukri-jobs-scraper --silent --output-dataset

```

## MCP server setup

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