# Naukri Jobs Scraper (`tacps126/naukri-jobs-scraper`) Actor

Scrape Naukri.com jobs by keyword and city: title, company, AmbitionBox rating, experience range, salary in lakhs (as rupee min/max), skills, full description, industry, department, qualifications and link. India's largest job board, no login needed. Filters and new-job monitoring.

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

## Pricing

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

Get job listings from **Naukri.com**, India's largest job board, by keyword and city as a clean, spreadsheet-ready dataset. Each job includes the title, company, the company's **AmbitionBox rating and review count**, the **experience range** in years, the city, the skills tagged on the posting, and the link to the job. With **Full job details** on (the default) you also get the **full description**, the **salary as a rupee min/max per year** when the employer shows it, the industry, department, qualifications and closing date. Export to JSON, CSV or Excel, send to Google Sheets or Slack, or call it as an API.

**Built for** recruiters and staffing agencies hiring in India, HR and compensation analysts, job boards and aggregators, sales teams looking for companies that are hiring, and job seekers who want new postings delivered to them.

### Why this scraper

- **Full job details.** Not just the search card: the complete description, salary, industry, department, education required and the date the posting closes, read from each job's own page.
- **Salary in numbers.** Naukri shows pay as text like `8-18 Lacs PA`. You get it as `{min: 800000, max: 1800000, currency: "INR", period: "year"}` as well, ready to sort and filter.
- **Experience in numbers.** `2-5 Yrs` becomes `yearsExperienceMin: 2`, `yearsExperienceMax: 5`.
- **Rich, standardized records.** Employment type, seniority, job function and work mode are filled in the same way as in our other job scrapers (Indeed, Glassdoor, LinkedIn, Greenhouse, Lever, Workday…), so you can combine sources in one table. The text Naukri shows is kept next to each normalized value (`employmentTypeRaw`, `experienceLevelRaw`, `salaryText`).
- **Many pages per search.** Up to 500 jobs per query and city (20 per results page).
- **New-job monitoring.** Schedule it with *Only new jobs* and each run returns only postings you haven't received yet, so you pay only for new ones.
- **Changes only.** Turn on *Changes only* and schedule it: each run returns only new jobs and jobs whose salary, location or title changed (with old and new values). Unchanged jobs are skipped and not charged.
- **Filters applied for you.** Title keywords, employment type, seniority, job function, minimum salary, "with salary only", excluded companies. Filtered-out jobs are never charged.
- **No account needed.** Nothing to log in to; the Actor reads the same pages any visitor sees.
- **Resilient.** If a search page doesn't load, it is retried automatically on a fresh connection. Results are saved as each search finishes, and a moved run resumes without charging twice.

### How to use it

1. Add **Search queries** (e.g. `python developer`, `data analyst`, `sales manager`) and **Locations** (e.g. `Bangalore`, `Pune`, `Delhi NCR`).
2. Optionally pick **Posted within** and set **Max jobs**.
3. Press **Start**. Download results from the **Output** tab, or connect an integration.

#### Example input

```json
{
  "queries": ["python developer", "data engineer"],
  "locations": ["Bangalore", "Hyderabad"],
  "datePosted": "7",
  "maxItems": 200
}
```

### What you get

| Field | Description |
|-------|-------------|
| `title` / `company` | Job title and employer |
| `companyRating`, `companyReviewCount`, `ambitionBoxUrl`, `companyId`, `companyUrl`, `companyLogo` | The employer's AmbitionBox rating, number of reviews and review page, its Naukri company id, page and logo |
| `location`, `city`, `countryCode` | Where the job is (Naukri lists several cities for many jobs) |
| `experienceLevelRaw`, `yearsExperienceMin`, `yearsExperienceMax` | Experience asked for, as shown (`2-5 Yrs`) and in numbers |
| `salary`, `salaryText` | `{min, max, currency, period, annualMin, annualMax}` in rupees, plus the text shown (`8-18 Lacs PA`), when the employer discloses pay |
| `skills` | Skills tagged on the posting |
| `description`, `summary` | Full job description (with details on) and a short summary |
| `industry`, `department`, `qualifications` | Industry, department / functional area and the education asked for |
| `employmentType`, `employmentTypeRaw` | `full_time`, `contract`… and Naukri's own label (`Full Time, Permanent`) |
| `seniority`, `jobFunction`, `workMode` | Derived from the title and text |
| `postedAtIso`, `postedDaysAgo`, `validThrough`, `applyBy` | Exact posting time, its age, and when it closes |
| `vacancies`, `walkIn` | Number of openings and walk-in interviews, when the employer says |
| `url`, `jobId` | Link to the job on Naukri and its id |
| `searchQuery`, `searchLocation` | Which search found it |

### Pricing

Pay per result: about **$1.50 per 1,000 jobs** with full details (lower on higher Apify plans) plus a tiny start fee. See the **Pricing** tab for exact rates, and set a maximum charge per run to cap spend. Duplicates, filtered-out jobs and (with *Only new jobs*) already-delivered jobs are free.

On Apify's **free plan** each run returns up to 100 jobs, enough to try it out. Any paid Apify plan removes the limit.

### FAQ

**Why do runs take a minute or two?** Naukri builds its pages in the browser, so every search opens Naukri in a real browser, and with *Full job details* on each job's page is opened too. Turn details off for a faster run with the search-card data only.

**Why are some salaries empty?** Many employers on Naukri choose "Not disclosed". Turn on *Only jobs with salary* to keep only jobs that show pay.

**Is it legal?** The Actor collects publicly listed job ads. You're responsible for how you use the data, including any personal data, under the laws that apply to you.

### Support

Found a problem or need a field that isn't there yet? Open an issue on the **Issues** tab with your input and what you expected. Requests decide what gets built next.

# Actor input Schema

## `queries` (type: `array`):

What to search for — job title, skill or company, one per line (e.g. `python developer`, `data analyst`, `Infosys`). Every query runs in every city.

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

City in India (e.g. `Bangalore`, `Pune`, `Delhi NCR`, `Hyderabad`), one per line. Leave empty to search all of India.

## `datePosted` (type: `string`):

Only jobs posted in this window.

## `experienceYears` (type: `integer`):

Only jobs that accept a candidate with this many years of experience (Naukri's own experience filter), e.g. `5`.

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

Maximum number of jobs to return in total. Naukri shows 20 jobs per results page; up to 500 per query and city.

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

Open each job's page for the full description, salary (when the employer shows it), industry, department, qualifications and closing date. Turn off for a faster run with the search-card data only (title, company, rating, experience, city, skills, short snippet).

## `titleIncludes` (type: `array`):

Keep a job only if its title contains any of these words (case-insensitive), e.g. `engineer`, `developer`.

## `titleExcludes` (type: `array`):

Drop a job whose title contains any of these words (case-insensitive), e.g. `intern`, `manager`.

## `locationIncludes` (type: `array`):

Keep a job only if its location contains any of these (case-insensitive), e.g. `Berlin`, `Remote`.

## `remoteOnly` (type: `boolean`):

Only jobs that say they're remote.

## `workModes` (type: `array`):

Keep only these work arrangements. Jobs whose posting doesn't state it are dropped when this is set.

## `employmentTypes` (type: `array`):

Keep only these employment types.

## `seniorities` (type: `array`):

Keep only these seniority levels.

## `jobFunctions` (type: `array`):

Keep only these job functions (engineering, data, sales, …).

## `descriptionIncludes` (type: `array`):

Keep a job only if its summary or skills mention any of these.

## `companyExcludes` (type: `array`):

Drop jobs from companies whose name contains any of these, e.g. staffing agencies.

## `minAnnualSalary` (type: `integer`):

Keep jobs paying at least this per year (hourly and monthly pay are converted), in the posting's currency. Jobs that don't publish pay are kept unless “Only jobs with salary” is on.

## `onlyWithSalary` (type: `boolean`):

Keep only jobs that publish their pay.

## `onlyNew` (type: `boolean`):

Return only jobs that no earlier run with the same input has delivered. Schedule the Actor and you pay only for new jobs.

## `changesOnly` (type: `boolean`):

Return only jobs that are new or changed since the last run with the same input (or monitor name): changed jobs carry `changeType: "changed"` and `changes` with the old and new salary, location or title. Search results are partial, so jobs that drop out aren't reported as closed. The first run returns everything as new.

## `monitorName` (type: `string`):

Optional name for the 'only new' history. Runs sharing a name share one history; leave empty to derive it from the sources.

## `delivery` (type: `object`):

Webhook: {"webhookUrl": "https://…", "format": "json" | "slack" | "discord", "onlyWhenResults": true, "includeItems": 10}. Google Sheets: {"spreadsheetId": "<id from the sheet URL>", "sheetName": "Sheet1"} plus the service account key below; share the sheet with the service account's e-mail first. Leave empty to only save results in the dataset.

## `googleServiceAccountJson` (type: `string`):

Only for Google Sheets delivery: paste the service account's JSON key. Stored encrypted; the account sees only sheets you share with it.

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

An Indian residential proxy is used by default — Naukri blocks cloud IPs on its search pages.

## `tenantId` (type: `string`):

Optional label used to keep separate histories for different clients or teams.

## `debug` (type: `boolean`):

Save extra diagnostics with the run.

## Actor input object example

```json
{
  "queries": [
    "python developer"
  ],
  "locations": [
    "Bangalore"
  ],
  "maxItems": 200,
  "includeDetails": true,
  "remoteOnly": false,
  "onlyWithSalary": false,
  "onlyNew": false,
  "changesOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debug": false
}
```

# Actor output Schema

## `results` (type: `string`):

The produced items (default dataset items).

# 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 = {
    "queries": [
        "python developer"
    ],
    "locations": [
        "Bangalore"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tacps126/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 = {
    "queries": ["python developer"],
    "locations": ["Bangalore"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tacps126/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 '{
  "queries": [
    "python developer"
  ],
  "locations": [
    "Bangalore"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call tacps126/naukri-jobs-scraper --silent --output-dataset

```

## MCP server setup

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