# Naukri Jobs Scraper | India Hiring & Salary Data (`keystonelabs/naukri-jobs-scraper`) Actor

Find Naukri jobs by keyword, city, experience and work mode. Export company names, skills, disclosed salary and apply links for recruiting research and job feeds. No Naukri login required.

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

## Pricing

$2.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

### Find hiring companies for a role in India

Naukri Jobs Scraper: Find Naukri jobs by keyword, city, experience and work mode. Export company names, skills, disclosed salary and apply links for recruiting research and job feeds. No Naukri login required.

### Start with a small example

1. Open Input, switch to JSON and paste the example below. Replace the example keywords with your own research targets when ready.
2. Check the live Pricing tab and set a run spending limit.
3. Run the Actor, then open the **Workflow** output view. Inspect `title`, `companyName`, `location`, `skills`, `salaryText`, `url`.
4. Export JSON for nested data or CSV for a spreadsheet. Review a small sample before increasing the scope.

```json
{
  "keywords": [
    "python developer"
  ],
  "maxItems": 20
}
```

At the rate checked September 9, 2026, 20 saved rows cost $0.040 in Actor event fees ($2.00 per 1,000 rows). Actual returned rows determine the event fee. Taxes and other account services may be separate.

### What can I use it for?

- **Lead generation for recruiters and staffing agencies.** Find companies with matching job listings for a role or skill in a city, with the company's Naukri profile and rating attached.
- **Sales prospecting.** Companies advertising for DevOps, Salesforce or SAP roles may be useful research candidates; a posting does not prove a purchase intention. Build a target list from their open positions.
- **Salary and market research.** Collect experience ranges and disclosed salary bands across thousands of postings for a role.
- **Job-feed aggregation.** Refresh a job board or newsletter daily with the newest postings for a set of keywords and cities.
- **Competitive hiring intelligence.** Track which competitors are hiring, where, and for what skills.
- **Candidate tooling.** Monitor new openings that match a profile and push them to a spreadsheet or a chat channel.

### What data does it return?

Each job produces one record. The fields buyers filter on most sit at the top level so the dataset is immediately usable in a spreadsheet or a database:

| Field | Example |
|---|---|
| `jobId` | `020926035302` |
| `title` | `Python Software Developer` |
| `companyName`, `companyId`, `companyUrl` | `HCLTech`, `4263814`, Naukri company page |
| `companyRating`, `companyReviewsCount` | `3.4`, `48459` |
| `location` | `Hybrid - Hyderabad, Chennai, Bengaluru` |
| `locations` | `["Hyderabad", "Chennai", "Bengaluru"]` |
| `workMode` | `On-site`, `Hybrid`, `Remote` or `Temporary WFH` |
| `experienceText`, `minExperience`, `maxExperience` | `7-12 Yrs`, `7`, `12` |
| `salaryText`, `salaryMin`, `salaryMax`, `currency` | `23-26 Lacs PA`, `2300000`, `2600000`, `INR` |
| `salaryDisclosed` | `false` for the majority of postings |
| `skills` | `["Django", "Python Development", "AWS", "Flask"]` |
| `descriptionSnippet` | First ~200 characters of the job description |
| `vacancies` | `4` |
| `postedAt`, `postedAgo` | `2026-09-03T14:35:25.144Z`, `1 Day Ago` |
| `url` | Full job-detail and apply page on Naukri |
| `applyRedirectUrl` | The company's own careers-site link, when the job applies off-Naukri |
| `logoUrl` | Company logo |
| `hiringFor`, `isConsultant` | Client name when a staffing agency posts on a client's behalf |
| `walkInInterview`, `diversityTag` | `true`, `Prefers women` |
| `searchKeyword`, `searchLocation`, `page`, `scrapedAt` | The query that produced the record |

Jobs are de-duplicated by `jobId` across all keywords in a run, so a posting that matches two of your keywords appears once.

#### Illustrative output

The example below explains the output shape; values are illustrative and are not a live result or a promise that every field is populated.

```json
{
  "jobId": "020926035302",
  "title": "Python Software Developer",
  "companyName": "HCLTech",
  "companyId": 4263814,
  "companyUrl": "https://www.naukri.com/hcltech-jobs-careers-460",
  "companyRating": 3.4,
  "companyReviewsCount": 48459,
  "location": "Hybrid - Hyderabad, Chennai, Bengaluru",
  "locations": ["Hyderabad", "Chennai", "Bengaluru"],
  "workMode": "Hybrid",
  "experienceText": "7-12 Yrs",
  "minExperience": 7,
  "maxExperience": 12,
  "salaryText": null,
  "salaryDisclosed": false,
  "salaryMin": null,
  "salaryMax": null,
  "currency": "INR",
  "skills": ["Django", "Python Development", "AWS", "Flask", "SQL", "Rest API Services", "Microservices", "Rest"],
  "descriptionSnippet": "Skill Requirements . Proficiency in python programming language for developing robust applications Experience designing and implementing microservices architecture or Rest API or flask",
  "vacancies": 4,
  "postedAt": "2026-09-03T14:35:25.144Z",
  "postedAgo": "1 Day Ago",
  "url": "https://www.naukri.com/job-listings-python-software-developer-hcltech-hyderabad-chennai-bengaluru-7-to-12-years-020926035302",
  "applyRedirectUrl": null,
  "walkInInterview": false,
  "searchKeyword": "python developer",
  "searchLocation": null,
  "page": 1,
  "scrapedAt": "2026-09-04T21:10:41.902Z"
}
```

### How to use it

1. Type one or more **Search keywords**, one per line. Each keyword is searched separately; results are merged and de-duplicated.
2. Optionally set a **Location** (one city or several separated by commas), **Years of experience**, **Posted within**, **Work mode** and **Sort by**. Choose *Freshness* when you want the newest postings first.
3. Set **Max jobs** to cap the run, then click **Start**.
4. Download the results as JSON, CSV, Excel or XML from the **Output** tab, or read them through the API.

For a daily feed, schedule the actor with *Posted within: Last 24 hours* and *Sort by: Freshness*, and each run returns only what is new.

#### Input

```json
{
  "keywords": ["python developer", "data engineer"],
  "location": "bengaluru, pune",
  "experience": 3,
  "jobAge": "7",
  "workMode": "any",
  "sortBy": "f",
  "maxItems": 200
}
```

### How it works

The actor calls the same JSON search endpoint Naukri's own website uses to render its listing pages, signs each request the way the site's front end does, and walks through the result pages 20 jobs at a time until it reaches your **Max jobs** limit or the last page. Naukri paginates deeply — pages well past 500 have been verified to return results — so there is no practical ceiling on how many jobs a single keyword can yield.

Every response is flattened into the record described above. Location labels are split into a city list and a work-mode flag, the comma-separated skill string becomes an array, timestamps become ISO 8601, and HTML is stripped from the description snippet. Jobs are pushed to the dataset as each page arrives, so partial results are available even if a later page fails.

Failed pages are logged and skipped rather than aborting the run; a search only stops early if three pages in a row fail or the site rejects the request signature.

### Pricing

You pay per job returned. There are no subscriptions or minimums, and you can cap the maximum spend of any run before starting it. A typical page costs one HTTP request for 20 jobs, so compute overhead is negligible.

### Scope and responsible use

This actor reads only public job advertisements posted by employers, exactly as any visitor sees them without signing in. It requires no account, no cookies and no credentials, never touches candidate profiles or any personal data, and does not attempt to bypass a CAPTCHA or any access control. You are responsible for using the results in accordance with the laws that apply to you and the terms of the sites you collect data from.

### Limitations

- **Description is a snippet, not the full text.** Naukri's search response carries only the first ~200 characters of each job description. The full description lives on the job-detail page, which is not accessible without a browser and is therefore not fetched. Use the `url` field to open it.
- **Salary is undisclosed on most postings.** In sampled searches roughly three out of four jobs showed *Not disclosed*; `salaryText`, `salaryMin` and `salaryMax` are `null` for those and `salaryDisclosed` is `false`.
- **Request signing may change.** The actor reproduces the signature Naukri's front end attaches to search requests. If Naukri rotates its key, every request returns HTTP 406 until the actor is updated; the run fails loudly with a clear message rather than returning empty data.
- **Platform IP blocks.** Searches succeed from ordinary IPs without a proxy. If runs start returning HTTP 406 on every page, enable **Proxy configuration** with residential proxies and country `IN`.
- Filters are applied by Naukri, so `experience` matches the site's own definition (the job's required range covers the given number of years).

### Something missing?

Open an issue on this actor's **Issues** tab with the input you used and what you expected. Reproducible problems are usually fixed within days.

### Before a larger run

Only returned job rows incur the per-row event fee; an empty result is not evidence that no matching jobs exist on the source. These are paid examples, not a free-results offer. No source-site API key is needed for the example in Console; programmatic Apify API access still requires Apify authentication.

Five internal launch smoke rounds passed on September 6, 2026. This describes small-input test coverage, not customer reviews, a service-level guarantee or a large-batch benchmark. Website behavior and data availability can change.

### Interpret empty results and errors

Check the run status and log if no records are returned. Restrictive filters, inaccessible content or a changed source page can produce an empty result; empty output does not prove there are no matching records on the source.

Billing follows saved job or company rows. Disclosed salary and optional fields may be missing. Proxy selection and run duration can affect operating costs. Do not increase concurrency or enable a more expensive proxy merely to work around an unclear result.

For a reproducible problem, open this Actor’s Issues tab with a small public input, expected behavior and relevant error text. Remove tokens and confidential information. No response-time or uptime guarantee is offered.

### Use the result in an automation

In Make or n8n, use the Apify integration to run this Actor with the same JSON input, wait for completion, then retrieve its default dataset. Route failed runs and error rows to a review step before sending valid results to your spreadsheet or CRM. Scheduling does not make these Actors emit only new records: deduplicate downstream using the source URL or record ID.

For Node.js, install the official `apify-client` package and set your own `APIFY_TOKEN` environment variable. The following example starts a paid run with a small spending limit.

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "keywords": [
    "python developer"
  ],
  "maxItems": 20
};
const run = await client.actor('keystonelabs/naukri-jobs-scraper').call(input, {
  memory: 512, timeout: 180, maxTotalChargeUsd: 0.10
});
if (run.status !== 'SUCCEEDED') throw new Error('Run did not succeed: ' + run.id);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
console.log(items);
```

The first 100 rows are retrieved in this example. Use the dataset API pagination for a larger result. Keep credentials out of shared inputs and source files.

### A useful next step

- [Wellfound Jobs Scraper | Remote Roles & Salaries](https://apify.com/keystonelabs/wellfound-jobs-scraper): build a remote startup-job shortlist. This is a separate Actor with its own input and price.

# Actor input Schema

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

Job titles, skills or company names, one per line — exactly what you would type into the Naukri search box. Each keyword runs as its own search. Leave empty to browse every job in a location.

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

City or region, e.g. "Bengaluru", "Delhi NCR", "Mumbai", "Hyderabad". Separate several with commas ("pune, hyderabad"). Leave empty for all of India.

## `experience` (type: `integer`):

Only jobs whose required experience range covers this many years (0 = fresher). Leave empty for any experience.

## `jobAge` (type: `string`):

Only jobs posted in the last N days.

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

Filter by where the job is performed.

## `sortBy` (type: `string`):

Relevance is Naukri's default ranking. Freshness returns the newest postings first — use it for daily monitoring.

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

Stop after this many unique jobs across all keywords. Naukri serves 20 jobs per page, so 100 jobs is 5 requests.

## `maxConcurrency` (type: `integer`):

How many keyword searches to run in parallel. Pages within one search are always fetched in order.

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

Optional. Route requests through Apify Proxy if Naukri starts answering with HTTP 406 from the platform's IP range. Residential proxies with country IN work best.

## Actor input object example

```json
{
  "keywords": [
    "python developer"
  ],
  "jobAge": "any",
  "workMode": "any",
  "sortBy": "r",
  "maxItems": 20,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset of scraped jobs. Each item carries title, company, rating, locations, work mode, experience, salary, skills, posted date and apply URL.

## `workflowJson` (type: `string`):

Selected columns for this workflow. Inspect errors and missing values before using the data.

## `workflowCsv` (type: `string`):

Download the workflow columns as CSV. Use JSON for full nested arrays.

# 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": [
        "python developer"
    ],
    "maxItems": 20
};

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

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

```

## MCP server setup

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