# Naukri Job Scraper (`webdata_labs/naukri-scraper`) Actor

\[💵 $1.50 / 1K · no start fee] Scrape Naukri.com and Naukrigulf jobs by keyword, location, URL or exact Naukri job ID. Clean company, salary, skills, experience, work mode and full descriptions.

- **URL**: https://apify.com/webdata\_labs/naukri-scraper.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 base 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's biggest job board, in a spreadsheet

**Scrape Naukri.com and Naukrigulf job listings into clean rows: title, company, salary, skills, experience and work mode. Search India, the Gulf, or both in one run.**

Naukri holds the largest pool of Indian job postings anywhere, and none of it is exportable. The website shows you 20 jobs at a time, hides the salary behind a label, and jams three cities and the work mode into one string. This Actor opens the public result pages in an isolated browser session, normalizes the cards, and hands you every field as its own column - no login and no start fee.

### 🔎 Why your Naukri search returns fewer jobs than Naukri claims

Naukri's match count is optimistic. In a measured run, a search claiming **3,751 jobs served 751 unique jobs** before the source ran dry. This Actor keeps paging, deduplicates repeated sponsored listings, and reports both Naukri's claimed count and the rows actually returned. Fewer rows than your limit usually means the source stopped serving results, not that the run silently failed.

### ✅ What you get / ❌ what this isn't

| ✅ This Actor gives you | ❌ This Actor is not |
|---|---|
| **Automatic browser pagination** beyond the first result page | Not a manual copy-paste workflow |
| **Up to 10,000 served cards per search** | Not just the first 20 jobs |
| **Many keywords x many cities in one run** | Not one run per search box |
| **India + Gulf coverage** through `platform: naukri / naukrigulf / both` | Not a separate Actor and schema for every region |
| **Exact `jobIds` refresh mode** for jobs you already track | Not a full search just to re-check one posting |
| **Salary as numbers** - `salaryMinLakhs`, `salaryMaxLakhs`, plus an honest `salaryDisclosed` flag | Not "12-22 Lacs PA" as a string you have to parse |
| **Work mode split out** of the location blob into `remote` / `hybrid` / `office` | Not "Hybrid - Pune, Chennai, Bengaluru" in one cell |
| **AmbitionBox rating and review count** on every row | Not a company name you have to look up separately |
| Full descriptions, education, role, industry, applicant and view counts on demand | Not a truncated card snippet |
| **No start fee** - a 5-job lookup costs 5 jobs | Not a per-run charge that punishes small queries |

### 🔎 Why use this Actor

- **It follows Naukri's current public browser flow.** Naukri replaced its reusable API signature with a single-use browser token in July 2026. The Actor now uses a real Chromium session instead of shipping a brittle hard-coded token.
- **Deep pagination with deduplication.** Naukri repeats promoted listings across pages, so rows are deduplicated by job id as they arrive and the Actor continues until your limit is met, the source runs dry, or the 500-page safety ceiling is reached.
- **Salary you can filter on.** Most Indian postings hide the salary. Rather than pretend, every row carries `salaryDisclosed`, and the numeric fields stay empty when it is false - so a "minimum 15 lakhs" filter never silently drops jobs whose pay is simply unknown.
- **Failure-aware collection.** Page timeouts and source blocks are reported in the run summary instead of being silently treated as an empty search.
- **Weekly new-jobs mode.** Turn on **Only jobs not seen in previous runs** and every scheduled run returns only postings you have not already been charged for.
- **Filters Naukri does not have.** Experience, salary band, work mode, freshness and employer type go to Naukri; exact salary floors, title must-include/must-exclude, company blocklists and a minimum AmbitionBox rating are applied on top.
- **Paste-a-URL mode.** Built the right search on naukri.com? Paste the URL and every filter in it is honoured.
- **Nothing to tune.** No proxy picker, no concurrency slider, no retry budget - the Actor handles all of that itself. You choose what to scrape and how much.
- **Naukrigulf support.** Select `naukrigulf` for UAE, Saudi Arabia, Qatar and the wider GCC, or `both` to run every keyword/location combination against India and Gulf sources. Every row carries `sourcePlatform`.

### 👥 Who it's for

Recruiters, staffing agencies, HR analysts and job-market researchers working across India and the Gulf.

- Build a live pipeline of open roles for a niche you recruit for, refreshed weekly.
- Benchmark pay bands by role, city and experience level using the disclosed-salary rows.
- Track which companies are hiring for which skills, and how fast their postings accumulate applicants.
- Feed a job board, a newsletter or an internal Slack alert with genuinely new postings only.
- Study demand for a technology across India by counting postings that name it.

### Example tasks

Ready-made configurations you can open, tweak and run:

- [Scrape Naukri Python developer jobs in Bangalore](https://apify.com/webdata_labs/naukri-scraper/examples/naukri-python-developer-jobs-bangalore)
- [Scrape remote jobs on Naukri across India](https://apify.com/webdata_labs/naukri-scraper/examples/naukri-remote-jobs-india)
- [Monitor Naukri jobs posted in the last 24 hours](https://apify.com/webdata_labs/naukri-scraper/examples/naukri-jobs-posted-today)
- [Find Naukri jobs paying above 25 lakhs](https://apify.com/webdata_labs/naukri-scraper/examples/naukri-high-salary-jobs-above-25-lakhs)
- [Scrape Naukri data analyst jobs with full descriptions](https://apify.com/webdata_labs/naukri-scraper/examples/naukri-data-analyst-jobs-with-descriptions)
- [Track which companies are hiring on Naukri](https://apify.com/webdata_labs/naukri-scraper/examples/naukri-jobs-for-recruiters-by-company)

### ⚙️ How to scrape Naukri jobs

1. Open the Actor on Apify.
2. Type one or more **search keywords**, for example `python developer`.
3. Optionally add **cities** - `bangalore`, `pune`, `delhi-ncr`. Leave empty to search all of India.
4. Set **Maximum jobs** - the budget for the whole run, shared across your searches. `0` means everything Naukri will serve.
5. Optionally narrow with experience, salary, work mode, freshness or employer type.
6. Optionally turn on **Fetch full job descriptions** for the complete text, education requirements, role, industry and applicant counts.
7. Click **Start**, then export as CSV, JSON or Excel.

Prefer a URL? Skip steps 2-5 and paste your naukri.com search URL into **Or paste Naukri search URLs**.

#### Get only the new jobs every week

Turn on **Only jobs not seen in previous runs**, save the configuration as a task, and schedule it. The Actor remembers every job it has returned, so run two gives you only what appeared since run one.

### 📥 Input

```json
{
  "searchQueries": ["python developer", "data engineer"],
  "locations": ["bangalore", "pune"],
  "maxItems": 500,
  "experienceYears": 5,
  "minSalaryLakhs": 15,
  "workMode": "remote",
  "postedWithinDays": "7",
  "employerType": "company",
  "includeJobDescription": true,
  "sortBy": "date"
}
```

- `searchQueries` - keywords as you would type them on Naukri. Each one is combined with each city, so 2 keywords x 2 cities is 4 searches.
- `locations` - Naukri's own city names (`bangalore`, `mumbai`, `delhi-ncr`, `hyderabad`, `chennai`, `pune`, `kolkata`, `remote`). Empty means all of India.
- `searchUrls` - paste naukri.com result-page URLs instead of building the search here.
- `platform` - `naukri` for India, `naukrigulf` for the GCC, or `both` to run every keyword and city against each.
- `jobIds` - refresh exact postings you already track, by their numeric Naukri id. Replaces the search.
- `maxItems` - total jobs for the run, shared across searches. Default 100, `0` means unlimited.
- `includeJobDescription` - fetch each job's own page for the full text and extra fields. One extra request per job. Off by default.
- `experienceYears` - keep jobs open to a candidate with this many years.
- `minSalaryLakhs` / `maxSalaryLakhs` - annual CTC bounds in lakhs. Re-checked exactly on every row.
- `onlyWithSalary` - drop the "Not disclosed" majority.
- `workMode` - `any`, `remote`, `hybrid` or `office`.
- `postedWithinDays` - `1`, `3`, `7`, `15` or `30`.
- `employerType` - `company` for direct employers, `consultancy` for staffing agencies.
- `minCompanyRating` - minimum AmbitionBox rating, 1-5.
- `titleMustInclude` / `titleMustExclude` - word filters on the job title.
- `excludeCompanies` - company names to skip entirely.
- `sortBy` - `relevance` (Naukri's default) or `date` for newest first.
- `onlyNewJobs` - return only postings no previous run has already delivered.

That is the whole input. There is nothing to configure about proxies, concurrency, retries or rate limits - the Actor manages those on its own.

### 📤 Output

One row per job:

| title | companyName | location | workMode | experienceLabel | salaryLabel | companyRating | postedAt |
|---|---|---|---|---|---|---|---|
| Senior Python Developer | Infosys | Pune, Chennai, Bengaluru | hybrid | 5-10 Yrs | Not disclosed | 3.5 | 2026-07-25T17:43:56Z |
| Data Engineer - AWS | Zomato | Gurugram | office | 3-6 Yrs | 18-28 Lacs PA | 3.8 | 2026-07-24T09:12:03Z |
| Backend Engineer (Remote) | Postman | Remote | remote | 4-8 Yrs | Not disclosed | 4.2 | 2026-07-23T11:05:44Z |

Every row also carries `jobId`, `jobUrl`, `companyId`, `companyUrl`, `companyLogoUrl`, `companyReviewsCount`, `companyReviewsUrl`, `isConsultancy`, `locations` as an array, `experienceMin` / `experienceMax` as numbers, `skills` as an array, `descriptionSnippet`, `salaryDisclosed`, `salaryMin` / `salaryMax` in rupees and `salaryMinLakhs` / `salaryMaxLakhs` in lakhs, `salaryCurrency`, `vacancies`, `postedLabel`, `diversityTag`, plus `searchQuery`, `searchLocation`, `totalJobsMatchingSearch` and `scrapedAt` so you can trace which search produced the row.

With **Fetch full job descriptions** on, each row gains `description` (plain text), `descriptionHtml`, `highlights`, `role`, `roleCategory`, `industry`, `functionalArea`, `employmentType`, `educationUg`, `educationPg`, `applyCount`, `viewCount`, `isWalkIn`, `companyDescription` and `companyWebsite`.

### 💵 How much does it cost?

You pay per job returned, and there is **no start fee** - a search that returns 5 jobs costs 5 jobs, not 5 jobs plus a run charge. Filtered-out rows are free: the salary, title and company filters run before anything is written to the dataset, so you are only billed for jobs that survived your criteria. A typical single-keyword city search matches thousands of jobs, so the **Maximum jobs** setting, not the search, is what decides your bill.

| Result | Free | Bronze | Silver | Gold and above |
|---|---:|---:|---:|---:|
| Base job (`job-scraped`) | $1.50 / 1,000 | $1.20 / 1,000 | $0.90 / 1,000 | $0.50 / 1,000 |
| Full detail (`job-detail-scraped`) | $4.50 / 1,000 | $3.60 / 1,000 | $2.70 / 1,000 | $1.50 / 1,000 |

Every returned row incurs the base event. A successful full-detail fetch incurs the detail event as well. Exact `jobIds` fetches are detail records, so both events apply.

### 🔁 Run it on the Apify platform

Schedule it daily or weekly, call it from the Apify API or any of the client libraries, export results as CSV, JSON, Excel or XML, or push rows straight into Make, Zapier, a webhook, Google Sheets or your ATS. The **Only jobs not seen in previous runs** switch is built for exactly this: schedule it once and every run delivers only the new postings.

### ⚠️ Limits and caveats

- **Most salaries are hidden.** Indian recruiters overwhelmingly post "Not disclosed", and Naukri returns zeros for those. The Actor reports `salaryDisclosed: false` rather than inventing a number, but it means pay-band analysis runs on a minority of rows.
- **Naukri search is browser-backed.** Expect roughly one page navigation per 20 served cards. Full descriptions require an additional job-page navigation per result, so large enriched runs are intentionally slower.
- **Naukrigulf full descriptions are not fetched yet.** Naukrigulf rows contain the public search-card summary in `descriptionSnippet`; `includeJobDescription` currently enriches Naukri.com rows only. Gulf rows are billed only at the base event.
- **No recruiter contact details.** Naukri does not expose recruiter emails or phone numbers to logged-out clients, and this Actor does not log in. Apply links go to the posting.
- **`vacancies` is often empty.** Naukri stores "unspecified" as a sentinel value; rather than pass that off as a headcount, the field is left blank.
- **Filters are Naukri's, with their quirks.** `experienceYears` matches against a job's range, not exactly; salary filtering is banded server-side and only refined exactly on rows where the salary is visible.
- **Sponsored listings are included.** Naukri injects promoted jobs into the result pages. They are deduplicated, but not labelled - there is no flag in the source to read.
- **Some rows have no posting date.** A handful of listings, mostly internships, carry no timestamp at all; where possible `postedAt` is reconstructed from the relative label Naukri shows.

### 🧩 Related Actors

- **[Company Career Page Jobs API](https://apify.com/webdata_labs/company-career-page-jobs-api)** - pull the same roles straight from a company's own careers page, to check whether a Naukri posting is still live.
- **[ATS Hiring Monitor API](https://apify.com/webdata_labs/ats-hiring-monitor-api)** - watch a company's applicant-tracking system for new openings between Naukri runs.
- **[Website Contact Extractor](https://apify.com/webdata_labs/website-contact-extractor)** - turn the employer names in your job rows into emails and phone numbers.
- **[Lead List Deduplicator](https://apify.com/webdata_labs/lead-list-deduplicator)** - merge several Naukri runs into one clean list without repeats.

### ❓ FAQ

**Am I charged for jobs that my filters remove?**
No. Title, company, rating and exact-salary filters run before rows reach the dataset, so you only pay for jobs you keep.

**Does it need a Naukri login or an API key?**
No. It reads only what naukri.com serves to a logged-out visitor.

**How deep does it really go?**
Deeper than you will usually want. A broad search paginates past 40,000 jobs. The practical limit is your **Maximum jobs** budget and how long you let the run go.

**Why is `salaryMinLakhs` empty on most rows?**
Because the recruiter hid the salary. Check `salaryDisclosed`; when it is `false` the numbers are deliberately blank rather than zero. Turn on **Only jobs with a disclosed salary** to keep only rows with real figures.

**How does the weekly new-jobs mode know what it has seen?**
It keeps the id of every job it has returned in storage that persists between runs, and skips those ids next time. Nothing to set up - just turn the switch on.

**Can I just paste a search URL from the website?**
Yes. Both URL shapes work - `naukri.com/python-developer-jobs-in-pune` and the query-string form with `k=` and `l=`.

**Does it cover internships and walk-in interviews?**
Yes, they come through the same search. Use `titleMustExclude` with `intern` or `walk-in` if you would rather not see them.

### 🛠️ Support

Something wrong or missing? Open an issue on the Actor's Issues tab with the run URL, the input you used and what you expected. Fixes usually ship the same week.

### ⭐ Rate this Actor

If this saved you time, please leave a review on the Reviews tab. Review count is the main trust signal buyers have on the Apify Store, and reviews are what decide which improvements get built next. If something is broken, please open an issue first - it will usually be fixed faster than a rating can be changed.

# Actor input Schema

## `searchQueries` (type: `array`):

Job titles, skills or technologies to search for, exactly as you would type them into Naukri's search box (for example 'python developer' or 'chartered accountant'). Every keyword is combined with every location below, so 3 keywords x 2 cities runs 6 searches in one go.

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

Cities or countries to restrict the search to (for example bangalore, mumbai, dubai, riyadh, uae). Leave empty to search the selected platform broadly.

## `platform` (type: `string`):

Scrape Naukri.com (India), Naukrigulf.com (GCC), or run the same keyword and location combinations on both.

## `searchUrls` (type: `array`):

Instead of building a search here, paste result-page URLs copied from naukri.com (for example https://www.naukri.com/python-developer-jobs-in-pune). Filters set in this input still apply on top, but anything in the URL wins.

## `jobIds` (type: `array`):

Refresh exact postings by their numeric Naukri job IDs. When set, search fields are ignored and full details are fetched.

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

How many jobs to return in total, shared across all searches. Set to 0 for every job Naukri will serve for your search (that can be tens of thousands, so raise the limit deliberately).

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

Fetch each job's own page to add the complete description, education requirements, role, industry, employment type, and how many people have applied and viewed it. This costs one extra request per job, so a large run takes noticeably longer. Off by default; a short description snippet is always included either way.

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

Keep only jobs open to a candidate with this many years of experience. Naukri matches this against each job's experience range, so 5 returns jobs asking for 3-8 years as well as 5-10.

## `minSalaryLakhs` (type: `integer`):

Lowest annual CTC to accept, in lakhs of rupees (10 means 10,00,000 INR). Naukri filters by salary band, so the exact figure is re-checked on every row. Jobs where the recruiter hid the salary are kept - see 'Only jobs with a disclosed salary' to drop them.

## `maxSalaryLakhs` (type: `integer`):

Highest annual CTC to accept, in lakhs of rupees. Useful for pay-band research; leave empty for no upper bound.

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

Drop every job whose salary Naukri shows as 'Not disclosed'. Most Indian postings hide salary, so expect this to remove the large majority of rows.

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

Restrict to remote, hybrid or on-site roles. 'Any' returns all three and still labels each row.

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

Only return jobs posted in the last N days. Naukri supports these windows natively, so narrowing here makes the run faster as well as smaller.

## `employerType` (type: `string`):

Company jobs are posted by the employer directly; consultancy jobs come from staffing agencies and are often duplicated across clients.

## `minCompanyRating` (type: `integer`):

Drop employers rated below this on AmbitionBox (1-5). Companies with no rating at all are dropped too, since there is nothing to check.

## `titleMustInclude` (type: `array`):

Keep only jobs whose title contains at least one of these words. Case-insensitive. Use it to cut the loosely related roles Naukri's keyword search pulls in.

## `titleMustExclude` (type: `array`):

Drop jobs whose title contains any of these words. Case-insensitive. Handy for stripping out 'intern', 'trainee' or 'walk-in' postings.

## `excludeCompanies` (type: `array`):

Company names to skip entirely, matched exactly as Naukri writes them. Useful for filtering out your own employer or the staffing firms that flood a search.

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

Naukri's own ordering. 'Freshness' walks the newest postings first, which is what you want for a monitoring run; 'Relevance' matches what the website shows by default.

## `onlyNewJobs` (type: `boolean`):

Remember every job this Actor has already returned and skip it next time, so a scheduled run gives you only genuinely new postings. The memory survives between runs.

## Actor input object example

```json
{
  "searchQueries": [
    "python developer"
  ],
  "locations": [
    "bangalore",
    "pune"
  ],
  "platform": "naukri",
  "searchUrls": [
    "https://www.naukri.com/data-scientist-jobs-in-bangalore"
  ],
  "jobIds": [
    "150126031660"
  ],
  "maxItems": 100,
  "includeJobDescription": false,
  "onlyWithSalary": false,
  "workMode": "any",
  "postedWithinDays": "any",
  "employerType": "any",
  "titleMustInclude": [
    "python",
    "backend"
  ],
  "titleMustExclude": [
    "intern",
    "trainee"
  ],
  "sortBy": "relevance",
  "onlyNewJobs": false
}
```

# Actor output Schema

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

No description

## `salary` (type: `string`):

No description

## `descriptions` (type: `string`):

No description

## `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 = {
    "searchQueries": [
        "python developer"
    ],
    "locations": []
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/12CoWwwkkVapCN4eK/builds/hVF0xaJdHuEImYTUF/openapi.json