# 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, 0 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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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.
- **Competitor-compatible inputs.** `keyword` aliases `searchQueries`, `startUrls` aliases `searchUrls`, and direct `jobIds` override search mode.
- **Exact taxonomy filters.** `companyId`, `industry` and `roleCategory` are sent to Naukri's API as IDs, so irrelevant rows are filtered before download and billing.
- **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 id it has returned in a named store, so run two gives you only what appeared since run one. Give each scheduled search its own **Name of the memory store** so two schedules do not hide each other's results.

### 📥 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.
- `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. Advanced.
- `titleMustInclude` / `titleMustExclude` - word filters on the job title. Advanced.
- `excludeCompanies` - company names to skip entirely. Advanced.
- `sortBy` - `relevance` (Naukri's default) or `date` for newest first.
- `onlyNewJobs` + `dedupStoreName` - the recurring-run dedup switch and which store remembers it.
- `maxConcurrency`, `requestsPerSecond`, `maxRequestRetries` - advanced controls for detail and API-backed collection paths. Naukri search-page navigation is sequential.
- `proxyConfiguration` - proxy settings used by the API-backed Naukrigulf path.

### 📤 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 stores every returned job id in a named key-value store that persists between runs. Change **Name of the memory store** to start a fresh memory, or to keep two schedules independent.

**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

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

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

## `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.

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

Compatibility alias for searchQueries. Used only when searchQueries is empty.

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

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

## `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.

## `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.

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

Compatibility alias for searchUrls. Accepts strings or Request objects with a url field.

## `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.

## `companyId` (type: `array`):

Exact Naukri company taxonomy IDs, applied by Naukri's search API.

## `industry` (type: `array`):

Naukri industryTypeIdGid taxonomy IDs.

## `roleCategory` (type: `array`):

Naukri roleTypeGid taxonomy IDs.

## `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 id this Actor has returned and skip them next time, so a scheduled run gives you only what is genuinely new. State is kept in a named key-value store that survives between runs.

## `dedupStoreName` (type: `string`):

Which named key-value store holds the 'already seen' job ids. Give each scheduled search its own name so they do not hide each other's results.

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

How many Naukri requests may be in flight at once. Higher is faster but more likely to be rate limited; the Actor slows itself down automatically when that happens.

## `requestsPerSecond` (type: `integer`):

Upper bound on requests per second across the whole run. The Actor starts here, halves the rate whenever Naukri pushes back, and climbs again once responses are clean. Lower it if you see rate-limit warnings in the log.

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried, with exponential backoff and a fresh proxy IP each time, before the page is recorded as failed and the run moves on.

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

Naukri rate limits per IP address, so large runs need proxy rotation to finish. Apify Proxy is enabled by default and is rotated automatically during the run.

## Actor input object example

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

# 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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri Job Scraper",
        "description": "[💵 $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.",
        "version": "0.1",
        "x-build-id": "YGSLqFnm8ThdSVxNz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~naukri-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-naukri-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/webdata_labs~naukri-scraper/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-naukri-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/webdata_labs~naukri-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-naukri-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "platform": {
                        "title": "Job board",
                        "enum": [
                            "naukri",
                            "naukrigulf",
                            "both"
                        ],
                        "type": "string",
                        "description": "Scrape Naukri.com (India), Naukrigulf.com (GCC), or run the same keyword and location combinations on both.",
                        "default": "naukri"
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword alias",
                        "type": "string",
                        "description": "Compatibility alias for searchQueries. Used only when searchQueries is empty."
                    },
                    "jobIds": {
                        "title": "Exact Naukri job IDs",
                        "type": "array",
                        "description": "Refresh exact postings by their numeric Naukri job IDs. When set, search fields are ignored and full details are fetched.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Cities or countries to restrict the search to (for example bangalore, mumbai, dubai, riyadh, uae). Leave empty to search the selected platform broadly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Or paste Naukri search URLs",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URL alias",
                        "type": "array",
                        "description": "Compatibility alias for searchUrls. Accepts strings or Request objects with a url field.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "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).",
                        "default": 100
                    },
                    "includeJobDescription": {
                        "title": "Fetch full job descriptions",
                        "type": "boolean",
                        "description": "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.",
                        "default": false
                    },
                    "experienceYears": {
                        "title": "Years of experience",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "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."
                    },
                    "companyId": {
                        "title": "Company ID",
                        "type": "array",
                        "description": "Exact Naukri company taxonomy IDs, applied by Naukri's search API.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "industry": {
                        "title": "Industry IDs",
                        "type": "array",
                        "description": "Naukri industryTypeIdGid taxonomy IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "roleCategory": {
                        "title": "Role category IDs",
                        "type": "array",
                        "description": "Naukri roleTypeGid taxonomy IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minSalaryLakhs": {
                        "title": "Minimum salary (lakhs per year)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "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": {
                        "title": "Maximum salary (lakhs per year)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Highest annual CTC to accept, in lakhs of rupees. Useful for pay-band research; leave empty for no upper bound."
                    },
                    "onlyWithSalary": {
                        "title": "Only jobs with a disclosed salary",
                        "type": "boolean",
                        "description": "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.",
                        "default": false
                    },
                    "workMode": {
                        "title": "Work mode",
                        "enum": [
                            "any",
                            "remote",
                            "hybrid",
                            "office"
                        ],
                        "type": "string",
                        "description": "Restrict to remote, hybrid or on-site roles. 'Any' returns all three and still labels each row.",
                        "default": "any"
                    },
                    "postedWithinDays": {
                        "title": "Posted within",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "15",
                            "30"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "any"
                    },
                    "employerType": {
                        "title": "Posted by",
                        "enum": [
                            "any",
                            "company",
                            "consultancy"
                        ],
                        "type": "string",
                        "description": "Company jobs are posted by the employer directly; consultancy jobs come from staffing agencies and are often duplicated across clients.",
                        "default": "any"
                    },
                    "minCompanyRating": {
                        "title": "Minimum company rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "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": {
                        "title": "Job title must include",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "titleMustExclude": {
                        "title": "Job title must not include",
                        "type": "array",
                        "description": "Drop jobs whose title contains any of these words. Case-insensitive. Handy for stripping out 'intern', 'trainee' or 'walk-in' postings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeCompanies": {
                        "title": "Exclude companies",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "relevance"
                    },
                    "onlyNewJobs": {
                        "title": "Only jobs not seen in previous runs",
                        "type": "boolean",
                        "description": "Remember every job id this Actor has returned and skip them next time, so a scheduled run gives you only what is genuinely new. State is kept in a named key-value store that survives between runs.",
                        "default": false
                    },
                    "dedupStoreName": {
                        "title": "Name of the memory store",
                        "type": "string",
                        "description": "Which named key-value store holds the 'already seen' job ids. Give each scheduled search its own name so they do not hide each other's results.",
                        "default": "naukri-seen-jobs"
                    },
                    "maxConcurrency": {
                        "title": "Parallel requests",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many Naukri requests may be in flight at once. Higher is faster but more likely to be rate limited; the Actor slows itself down automatically when that happens.",
                        "default": 10
                    },
                    "requestsPerSecond": {
                        "title": "Request rate ceiling",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Upper bound on requests per second across the whole run. The Actor starts here, halves the rate whenever Naukri pushes back, and climbs again once responses are clean. Lower it if you see rate-limit warnings in the log.",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "Retries per request",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times a failed request is retried, with exponential backoff and a fresh proxy IP each time, before the page is recorded as failed and the run moves on.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Naukri rate limits per IP address, so large runs need proxy rotation to finish. Apify Proxy is enabled by default and is rotated automatically during the run.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
