# 💼 Naukri Job Scraper — India + Gulf · Emails & 41 Fields (`scraper-engine/naukri-jobs-scraper`) Actor

Naukri Job Scraper extracts public job listings across India and Gulf markets with 41 structured fields, including titles, companies, locations, salaries, skills, descriptions, application details, and publicly available emails for recruitment and job market research.

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

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Naukri Job Scraper — India + Gulf · Emails & 41 Fields

Scrape job postings from Naukri.com (India) and Naukrigulf.com (UAE, Saudi Arabia, Qatar, Egypt and the wider GCC) and get back structured JSON — job title, employer, salary bands, experience range, key skills, and an optional employer contact email per row. Paste Start URLs, build a keyword + location search, or fetch specific job IDs directly; every row streams to the dataset as soon as it's scraped, with no HTML parsing required on your end. Start a run on the Actor's Apify Store page to see it working on a live search.

### What is Naukri Job Scraper — India + Gulf · Emails & 41 Fields?

It's an Apify Actor that pulls job-posting data from Naukri.com and Naukrigulf.com and returns it as typed JSON — up to 41 fields per Naukri job, covering identity, company detail, compensation, experience, education, skills, and engagement metrics, plus optional AmbitionBox company ratings and employer email/payment-processor enrichment. No Naukri or Naukrigulf account is required — the Actor talks to each site's own public job-search and job-detail endpoints anonymously, the same ones a logged-out visitor's browser calls. It's built for recruiters, sales/lead-gen teams, job-market researchers, and developers or AI agents that need clean job data without maintaining their own scraper.

### What Naukri and Naukrigulf job data is publicly available to scrape?

Naukri.com and Naukrigulf.com expose full job-posting detail — title, company, salary, experience, skills, and description — to any visitor without signing in, which is exactly what this Actor reads.

| Data Category | Publicly Available (no login) | Restricted (requires a job-seeker account) |
| --- | --- | --- |
| Job title, description, skills, education requirements | Yes | — |
| Salary band, experience range, employment/work type | Yes | — |
| Employer name, logo, address, company overview link | Yes | — |
| Job view/apply counts, posted date, vacancies | Yes | — |
| AmbitionBox company rating, review count, top reviews | Yes (public review site) | Full review history & salary insights beyond the job page |
| Actually applying to a job / uploading a resume | — | Requires a Naukri or Naukrigulf job-seeker account |
| Recruiter's direct phone/email inside Naukri itself | — | Naukri does not expose this to any visitor, login or not |

Naukri Job Scraper — India + Gulf · Emails & 41 Fields only returns publicly visible data — what any visitor sees. Nothing behind a login wall. The optional employer-email enrichment doesn't come from Naukri at all — it separately looks up the hiring company's own public website (see the Legal section below).

### What data can I extract with Naukri Job Scraper — India + Gulf · Emails & 41 Fields?

Every scraped job returns identity and company fields, compensation and requirement fields, and engagement/timestamp fields — 41 keys in total for a Naukri.com row, plus up to 8 more optional keys when enrichment is switched on.

#### Job & employer identity

| Field Name | Description |
| --- | --- |
| `jobId` | Naukri's internal numeric job ID |
| `title` | Job title |
| `staticUrl` | Direct URL to the job posting |
| `url` | Canonical job URL (same value as `staticUrl`) |
| `companyDetail` | Object: `name`, `websiteUrl`, `details`, `address`, `hiringFor` |
| `staticCompanyName` | URL to every open job at this employer |
| `companyId` | Naukri's internal company ID |
| `clientLogo` | Employer logo image URL |
| `banner` | Employer banner image URL |
| `groupId` | Company group ID (used for company-wide job listing) |
| `companyOverviewUrl` | URL to the employer's Naukri company-overview page |
| `companyJobsUrl` | URL to every open job at this employer (same as `staticCompanyName`) |
| `companyDescription` | Employer description (HTML) |
| `basicInfo` | Object: `jobId`, `title`, `companyName`, `companyId`, `jdURL`, `createdDate` |
| `mode` | Posting mode/source, as reported by Naukri |
| `consultant` | `true` if posted by a recruitment consultant rather than the employer directly |
| `companyApplyJob` | `true` if applying routes to the employer's own site rather than Naukri |
| `scrapedFrom` | How this job was found: `search-results`, `company-overview`, or `direct-fetch` |

#### Compensation, experience & requirements

| Field Name | Description |
| --- | --- |
| `salaryDetail` | Object: `minimumSalary`, `maximumSalary`, `currency`, `label`, `variablePercentage`, `hideSalary` |
| `salaryPerMonth` | Per-month salary figure, when Naukri publishes one |
| `minimumExperience` | Minimum years of experience required |
| `maximumExperience` | Maximum years of experience accepted |
| `experienceText` | Human-readable experience range, e.g. `2-5 Yrs` |
| `education` | Object: `ug[]`, `pg[]`, `ppg[]` — accepted degree lists |
| `roleCategory` | Naukri role-category label |
| `jobRole` | Naukri job-role label |
| `industry` | Industry label |
| `functionalArea` | Functional-area label |
| `employmentType` | Employment type (e.g. full-time, contract) |
| `jobType` | Job-post type label |
| `wfhType` | Work-from-home type code: `0` office, `1` temp. WFH, `2` remote/WFH, `3` hybrid |
| `wfhLabel` | Human-readable work-mode label matching `wfhType` |
| `keySkills` | Object: `other[]`, `preferred[]` — key-skill lists |
| `locations` | Job location(s), as returned by Naukri's own job-detail API |
| `vacancy` | Number of open vacancies |

#### Description, engagement, timestamps & optional enrichment

| Field Name | Description |
| --- | --- |
| `description` | Full job description (HTML, or plain text if Clean HTML is on) |
| `shortDescription` | Short job description/summary |
| `viewCount` | Number of times the job was viewed on Naukri |
| `applyCount` | Number of applicants so far, as reported by Naukri |
| `createdDate` | Date the job was posted |
| `scrapedAt` | UTC timestamp this row was scraped |
| `ambitionBox` | Present only when Include AmbitionBox Ratings is on. Object: `url`, `rating`, `reviewsCount`, `topReviews[]` (up to 5), `salariesUrl` |
| `contactWebsite` | Present only when Enrich Employer Emails is on and a matching company website was found |
| `contactEmail` | First public email address found on the employer's site, if any |
| `emailEnrichment` | Object: `domain`, `pagesChecked`, `emailsFound[]` — every email found, not just the first |
| `takesPayments` | Present only when Qualify by Payment Processor is on — `true` if a payment-processor signature was detected on the employer's site |
| `paymentProcessors` | Array of detected processor names (Stripe, PayPal, Shopify, Paddle, Lemon Squeezy, WooCommerce, Square, Chargebee, Razorpay, Braintree) |
| `paymentConfidence` | `high`, `medium`, or `low`, based on how many signatures matched |
| `stripeLiveKey` | Present only if a live Stripe publishable key was found on the employer's site |

⚠️ Naukrigulf rows use the same 41-field shape, but several fields always come back `null`/empty for Naukrigulf — no separate Naukrigulf job-detail endpoint exists, so `education`, `keySkills.preferred`, `functionalArea`, `roleCategory`, `industry`, `wfhType`/`wfhLabel`, `salaryDetail`, `viewCount`, `applyCount`, and `ambitionBox` are only ever populated for Naukri.com rows.

#### 🤖 Add-on: Need additional job or recruiting data?

Pair this Actor with [ATS Jobs API](https://apify.com/testt0/ats-jobs-api) to pull listings straight from a company's own Greenhouse, Lever, Ashby, Workable, or SmartRecruiters board, or [Greenhouse Job Scraper](https://apify.com/testt0/greenhouse-job-scraper) for Greenhouse-hosted career pages specifically. For candidate-side sourcing to go with your job data, [LinkedIn People Profile Scraper](https://apify.com/testt0/linkedin-people-profile-scraper) pulls bulk LinkedIn profiles with the same live, per-section output pattern.

### Why not build this yourself?

Naukri and Naukrigulf don't publish a public API for third-party job search — there's no documented endpoint, rate-limit policy, or approval process to build against, so any DIY scraper has to reverse-engineer the same internal JSON APIs this Actor uses. Naukri.com additionally signs every search and job-detail request with an RSA-encrypted `nkparam` token whose signing key, endpoint path, and app ID are re-derived from the site's own JavaScript bundles on every deploy — a scraper that hardcodes these breaks the next time Naukri ships a frontend update. On top of that, Naukri's bot-defense returns HTTP 403/406/429 once a request pattern looks automated, which means building and maintaining a proxy-escalation strategy, a shared cookie/session jar, and retry/backoff logic — all before you've written a single line of field-mapping code for two structurally different sites (Naukri.com and Naukrigulf.com use entirely separate APIs with different response shapes).

This Actor already does all of that: it re-extracts the signing key live when the pinned one stops working, escalates through a proxy ladder automatically, and maps both platforms onto one consistent output schema.

### How to use Naukri Job Scraper — India + Gulf · Emails & 41 Fields

The Actor runs entirely inside the Apify platform — no separate account with Naukri or Naukrigulf is needed.

1. Open the Actor's page in the [Apify Store](https://apify.com/store) and click **Try for free** (or **Start**, if you already have it saved).
2. Provide input — every field is optional, so the simplest run just needs nothing at all: leaving `startUrls`, `jobIds`, `searchQuery`, and `location` blank defaults to a `developer` search in `india`. For a targeted run, set `searchQuery` and `location`, or paste one or more URLs into `startUrls`.
3. Set any optional filters worth using — `maximumJobs` to cap the run, `timeFilter` or `freshnessDays` to limit by posting age, `minSalary` to drop low-paying rows, or `enrichEmails`/`includeAmbitionBoxDetails` to turn on enrichment.
4. Click **Start**. Rows are pushed to the dataset live, one per job, the moment each is scraped — you don't have to wait for the whole run to finish to see results. This Actor bills on the Pay-Per-Event model: each job saved to the dataset fires one `row_result` event, and a job that fails or gets filtered out is never pushed, so you're never charged for a row you don't receive.
5. Download results from the **Output** tab as JSON, CSV, Excel, or via the API, or stream them straight into another tool.

#### How to scale to bulk job extraction

`startUrls`, `jobIds`, and `cities` are all array inputs, so one run already handles bulk input: paste dozens of search/company/job URLs into `startUrls` and they're each classified and scraped in the same run, list several Naukri job IDs in `jobIds` to refresh a specific batch, or add extra cities to `cities` to fan a single keyword search out across multiple locations (merged up to `maximumJobs`). `maxConcurrency` (default 10, up to 50) controls how many job pages are fetched in parallel within that one run.

### What can you do with Naukri and Naukrigulf job data?

- 📧 **A B2B sales rep prospecting new accounts** uses `contactEmail` and `companyDetail.name` from newly posted jobs to build an outreach list of companies that are actively hiring — a live buying-intent signal.
- 📊 **A compensation analyst benchmarking pay** filters on `salaryDetail` and `experienceText` across a role and city to see where local salary bands sit for a given experience level.
- 🧑‍💼 **A recruiter tracking competitor hiring** uses `title`, `keySkills`, and `createdDate` from a competitor's `companyOverviewUrl` jobs to see which roles and skills they're actively recruiting for.
- 💳 **A SaaS lead-qualification team** turns on `qualifyByPayment` and filters on `takesPayments` and `paymentConfidence` to prioritize employers that already process online payments — a signal for B2B/SaaS fit.
- 🤖 **An AI agent building a job-market briefing** feeds `description`, `keySkills`, and `salaryDetail` from a batch of scraped jobs into an LLM prompt or a RAG index to answer questions like "what does this role typically pay" without any manual data entry.

### How does Naukri Job Scraper — India + Gulf · Emails & 41 Fields handle rate limits and blocking?

By default every request goes directly to Naukri/Naukrigulf with no proxy at all, for speed. If a request comes back blocked (HTTP 403, 406, or 429 — Naukri's bot-defense returns 406 "recaptcha required" once a request pattern looks automated — or any 5xx server error), the Actor automatically escalates through a proxy ladder: no proxy → Apify Proxy datacenter → Apify Proxy residential, retrying up to 3 times on residential before giving up on that one request. Once the run reaches residential, it stays there for every remaining request rather than dropping back down, and every escalation is logged. Naukri.com's requests are also signed with a token whose signing key is self-healing: if the pinned key stops working, the Actor re-derives a fresh one from the site's live JavaScript bundles automatically, mid-run. Each request retries up to `maxRequestRetries` times (default 10, max 15) with increasing backoff; if 12 consecutive requests fail at the transport level (no response reaches the site at all), the run stops making new requests but keeps whatever was already saved to the dataset.

### ⬇️ Input

All 29 input fields are optional — an empty input runs a default `developer` search in `india`.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `startUrls` | No | array | Naukri/Naukrigulf search, company-overview, or direct job-detail URLs, mixed freely. Non-empty means every filter field below is ignored. | `["https://www.naukri.com/development-programmer-jobs?k=development"]` |
| `jobIds` | No | array | Exact Naukri job IDs to fetch directly. Overrides Start URLs and every filter. | `["091025500280"]` |
| `platform` | No | string | Naukri.com vs Naukrigulf.com for filter-built search only. Default `"naukri"`. Enum: `naukri`, `naukrigulf`. | `"naukri"` |
| `searchQuery` | No | string | Job title, role, or keyword (filter mode). Default `"developer"`. | `"data scientist"` |
| `location` | No | string | City, region, or country (filter mode). Default `"india"` (falls back to `"dubai"` for Naukrigulf if blank). | `"bangalore"` |
| `cities` | No | array | Extra cities — each runs its own search, merged up to Maximum Jobs. | `["pune", "hyderabad"]` |
| `maximumJobs` | No | integer | Stop after this many jobs, across every URL/city combined. Default `10`, minimum `1`. | `100` |
| `sortBy` | No | string | Order by relevance or freshness. Default `"relevance"`. Enum: `relevance`, `date`. | `"date"` |
| `experienceLevel` | No | integer | Minimum years of experience (filter mode). Minimum `0`. | `3` |
| `jobType` | No | string | Forwarded to Naukri's job-post-type filter where supported. | `"Full Time"` |
| `workMode` | No | string | Comma-separated work-mode codes: `0` office, `1` temp WFH, `2` remote/WFH, `3` hybrid. | `"2,3"` |
| `industry` | No | string | Single industry name or ID, matched against Naukri's live options. | `"IT Services & Consulting"` |
| `roleCategory` | No | string | Single role-category name or ID, matched against Naukri's live options. | `"Software Development"` |
| `companyType` | No | array | Company-type names or IDs, multi-select. | `["Product"]` |
| `salaryRange` | No | array | Multi-select annual CTC bands (₹ Lacs/year). Enum: `0to3, 3to6, 6to10, 10to15, 15to25, 25to50, 50to75, 75to100, 100to500, 501`. | `["10to15", "15to25"]` |
| `department` | No | array | Naukri department/functional-area, multi-select. Enum: `"1"`–`"37"` (37 named departments, e.g. `"3"` = Data Science & Analytics). | `["3"]` |
| `ugCourse` | No | array | Required undergraduate degree, multi-select. Enum: 25 numeric-string IDs (e.g. `"18"` = Any Graduate). | `["18"]` |
| `pgCourse` | No | array | Required postgraduate degree, multi-select. Enum: 25 numeric-string IDs (e.g. `"19"` = Any Postgraduate). | `["19"]` |
| `timeFilter` | No | string | Keep only jobs posted within this window; unparseable dates always pass. Enum: `24h`, `7d`, `30d`, `90d`. | `"7d"` |
| `freshnessDays` | No | integer | Server-side "posted in the last N days" filter. Minimum `1`. | `15` |
| `minSalary` | No | integer | Drop rows below this annual salary; hidden/missing salary always passes. Default `0`, minimum `0`. | `600000` |
| `includeDescription` | No | boolean | Include full HTML description + short description in each row. Default `true`. | `true` |
| `cleanHtml` | No | boolean | Strip HTML tags from description fields. Only applies if `includeDescription` is on. Default `false`. | `false` |
| `includeAmbitionBoxDetails` | No | boolean | Enrich each Naukri row with the employer's AmbitionBox rating, review count, and top reviews. Naukri.com rows only. Default `false`. | `true` |
| `enrichEmails` | No | boolean | Look up the hiring company's site and scan its home/contact/about pages for a public contact email. Default `false`. | `true` |
| `qualifyByPayment` | No | boolean | Meaningful only with `enrichEmails` on — scans the same pages for payment-processor signatures. Default `false`. | `false` |
| `proxyConfiguration` | No | object | Apify Proxy configuration. Defaults to no proxy, with automatic escalation on a block. | `{"useApifyProxy": false}` |
| `maxConcurrency` | No | integer | How many job pages to fetch in parallel. Default `10`, minimum `1`, maximum `50`. | `10` |
| `maxRequestRetries` | No | integer | How many times to retry a single request before giving up on it. Default `10`, minimum `1`, maximum `15`. | `10` |

#### Example input

```json
{
    "searchQuery": "data scientist",
    "location": "bangalore",
    "cities": ["pune", "hyderabad"],
    "maximumJobs": 50,
    "sortBy": "date",
    "experienceLevel": 3,
    "salaryRange": ["10to15", "15to25"],
    "timeFilter": "7d",
    "minSalary": 1000000,
    "includeDescription": true,
    "cleanHtml": true,
    "includeAmbitionBoxDetails": true,
    "enrichEmails": true,
    "qualifyByPayment": true,
    "proxyConfiguration": { "useApifyProxy": false },
    "maxConcurrency": 10,
    "maxRequestRetries": 10
}
```

### ⬆️ Output

Every scraped job is a single, flat JSON object pushed to the dataset the instant it's ready, with the same 41-field shape on every row regardless of which search mode found it. Export the results as JSON, CSV, or Excel from the Output tab, or read them via the Apify API — and switch between the Overview, Company, Compensation & Experience, Skills & Education, Engagement & Activity, and Lead-Gen Enrichment table views to browse one slice of the data at a time instead of scrolling raw JSON.

#### Example output

```json
{
    "jobId": "310826502091",
    "title": "Senior Data Scientist",
    "staticUrl": "https://www.naukri.com/job-listings-senior-data-scientist-acme-analytics-bangalore-3-to-6-years-310826502091",
    "description": "<p>We are looking for a Senior Data Scientist to join our Bangalore team...</p>",
    "shortDescription": "Build and deploy ML models for demand forecasting and pricing.",
    "companyDetail": {
        "name": "Acme Analytics Pvt Ltd",
        "websiteUrl": "https://www.acmeanalytics.com",
        "details": "Acme Analytics is a data science consultancy serving retail and fintech clients.",
        "address": "Bangalore, Karnataka",
        "hiringFor": "Acme Analytics Pvt Ltd"
    },
    "staticCompanyName": "https://www.naukri.com/acme-analytics-jobs-careers-123456",
    "companyId": 123456,
    "clientLogo": "https://img.naukimg.com/logo_images/groups/v1/123456.gif",
    "banner": null,
    "salaryDetail": {
        "minimumSalary": 1000000,
        "maximumSalary": 1500000,
        "currency": "INR",
        "label": "10-15 Lacs PA",
        "variablePercentage": 10,
        "hideSalary": false
    },
    "minimumExperience": 3,
    "maximumExperience": 6,
    "experienceText": "3-6 Yrs",
    "education": {
        "ug": ["B.Tech/B.E."],
        "pg": ["MBA/PGDM", "MCA"],
        "ppg": []
    },
    "roleCategory": "Data Science & Machine Learning",
    "jobRole": "Data Scientist",
    "industry": "IT Services & Consulting",
    "functionalArea": "Data Science & Analytics",
    "employmentType": "Full Time, Permanent",
    "jobType": "Full Time",
    "wfhType": "3",
    "wfhLabel": "Hybrid",
    "locations": ["Bangalore"],
    "keySkills": {
        "other": ["Python", "Machine Learning", "SQL"],
        "preferred": ["PySpark", "MLOps"]
    },
    "vacancy": 2,
    "viewCount": 4820,
    "applyCount": 312,
    "createdDate": "2026-08-25 10:12:00",
    "consultant": false,
    "groupId": 654321,
    "mode": "web",
    "companyApplyJob": false,
    "companyDescription": "Acme Analytics is a data science consultancy serving retail and fintech clients.",
    "companyOverviewUrl": "https://www.naukri.com/acme-analytics-overview-654321",
    "companyJobsUrl": "https://www.naukri.com/acme-analytics-jobs-careers-123456",
    "salaryPerMonth": 100000,
    "url": "https://www.naukri.com/job-listings-senior-data-scientist-acme-analytics-bangalore-3-to-6-years-310826502091",
    "scrapedFrom": "search-results",
    "basicInfo": {
        "jobId": "310826502091",
        "title": "Senior Data Scientist",
        "companyName": "Acme Analytics Pvt Ltd",
        "companyId": 123456,
        "jdURL": "https://www.naukri.com/job-listings-senior-data-scientist-acme-analytics-bangalore-3-to-6-years-310826502091",
        "createdDate": "2026-08-25 10:12:00"
    },
    "scrapedAt": "2026-09-01T09:14:22.531Z",
    "ambitionBox": {
        "url": "https://www.ambitionbox.com/overview/acme-analytics-overview",
        "rating": 4.1,
        "reviewsCount": 286,
        "topReviews": [
            { "title": "Good work-life balance", "rating": 4, "likes": "Flexible hours", "dislikes": "Limited career growth", "publishedOn": "2026-06-10", "link": "https://www.ambitionbox.com/reviews/acme-analytics-reviews" }
        ],
        "salariesUrl": "https://www.ambitionbox.com/salaries/acme-analytics-salaries"
    },
    "contactWebsite": "https://acmeanalytics.com",
    "contactEmail": "careers@acmeanalytics.com",
    "emailEnrichment": {
        "domain": "acmeanalytics.com",
        "pagesChecked": 2,
        "emailsFound": ["careers@acmeanalytics.com", "info@acmeanalytics.com"]
    },
    "takesPayments": true,
    "paymentProcessors": ["Stripe"],
    "paymentConfidence": "medium"
}
```

### How does it work?

For Naukri.com, the Actor calls the site's own internal `jobapi` search and job-detail endpoints — the same ones the naukri.com website itself calls — signing each request with the RSA-encrypted token Naukri's frontend generates client-side. It keeps one shared cookie session per run (Naukri's bot-defense gates its search API on a cookie set by an initial page load) and re-derives the signing key live from Naukri's own JavaScript bundles if the pinned one ever stops working, so the Actor keeps working across Naukri frontend redeploys without a manual update. Naukrigulf.com uses a separate, unsigned public search endpoint with no such token. Every request routes through a proxy ladder — direct, then datacenter, then residential — that escalates automatically only when a request is actually rejected. Only data any logged-out visitor can already see is ever returned, and the 41-field output shape stays the same regardless of which mode found the job or how either site's page layout changes.

### Integrations

Every Apify Actor, including this one, is reachable over HTTP through the Apify API, so it works with whatever you already use to make API calls.

#### Calling Naukri Job Scraper — India + Gulf · Emails & 41 Fields programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")
run = client.actor("<YOUR_APIFY_USERNAME>/naukri-job-scraper-india-gulf-emails-41-fields").call(
    run_input={
        "searchQuery": "data scientist",
        "location": "bangalore",
        "maximumJobs": 100,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["companyDetail"]["name"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In **n8n**, use the HTTP Request node pointed at the Actor's `run-sync-get-dataset-items` endpoint with your Apify API token in the Authorization header, and feed the returned JSON array straight into downstream nodes. In **Make**, either the native Apify app's "Run Actor" module or a plain HTTP module calling the same endpoint works the same way. In **LangChain**, the `langchain-apify` package's Apify tool wrapper can call this Actor by its ID and hand the resulting dataset items directly to an agent or chain as tool output.

### Is it legal to scrape Naukri and Naukrigulf job postings?

Scraping publicly accessible job-posting data — the kind any visitor can see without logging in — is generally permissible, and Naukri Job Scraper — India + Gulf · Emails & 41 Fields only ever returns that. The core 41-field job data (title, company, salary, skills, description) is business/product data about a job posting, not personal data about an individual, so no personal-data regime applies to it — your use is governed by Naukri's and Naukrigulf's own terms of service rather than GDPR or CCPA. The optional email enrichment is different: it scans a hiring company's own public website pages for a contact email, and that email can sometimes identify a specific person rather than a generic inbox — treat any stored `contactEmail`/`emailEnrichment` values as personal data under GDPR/CCPA if they identify an individual, and have a lawful basis before storing or using them for outreach. Consult legal counsel if your use case involves bulk storage of personal data.

### Frequently asked questions

#### What Naukri and Naukrigulf job fields does this Actor return?

The top fields are `title`, `companyDetail.name`, `salaryDetail`, `experienceText`, and `keySkills`, alongside 36 more identity, compensation, and engagement fields — see the [data fields section](#what-data-can-i-extract-with-naukri-job-scraper--india--gulf--emails--41-fields) above for the full list.

#### Does it require a Naukri or Naukrigulf account or login?

No. The Actor makes anonymous HTTP requests to each site's own public search and job-detail endpoints — the same calls a logged-out browser makes — so no Naukri or Naukrigulf credentials are needed.

#### How many jobs can I extract in one run?

`maximumJobs` has no fixed upper bound (its default is `10`, minimum `1`) — set it as high as the number of jobs you need. Internally, each keyword/location search stops paging after an internal safety cap of 2,000 pages, which in practice is far beyond what any single search on either site returns.

#### What happens if a job posting is expired, removed, or unreachable?

That job is skipped, counted as failed in the run log, and never pushed to the dataset — it doesn't stop the rest of the run. ⚠️ One real limitation: Naukrigulf job IDs pasted into `jobIds` or as direct job URLs in `startUrls` are also skipped with a warning, since no confirmed Naukrigulf job-detail endpoint exists — use a Naukrigulf search URL or `platform: "naukrigulf"` filter mode instead to get Naukrigulf rows.

#### Can I scrape multiple Naukri or Naukrigulf jobs at once?

Yes. `startUrls` and `jobIds` both accept arrays, so one run can mix any number of search pages, company pages, direct job links, or specific job IDs, and `cities` lets one keyword search fan out across multiple locations in the same run.

#### Does this Actor work with Claude, ChatGPT, and other AI agent tools?

Yes — since it's callable as a plain HTTP endpoint through the Apify API, any agent framework that can make an HTTP call (LangChain, custom Claude/ChatGPT tool integrations, or any other agent runtime) can trigger a run and read back the resulting dataset.

#### Can I run this Actor against both Naukri.com and Naukrigulf.com in a single run?

Yes. Mix Naukri and Naukrigulf URLs freely in `startUrls` — each is classified automatically and scraped with the platform-appropriate logic — or run it twice with `platform` set to `naukri` and `naukrigulf` respectively for filter-built searches.

#### Does this Actor return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors required. Pass it directly to an LLM prompt, index it into a vector store, or feed it to an agent tool as-is.

#### What happens when Naukri or Naukrigulf changes its layout or anti-bot system?

The Actor is maintained, and its output schema is designed to stay stable across site changes — for Naukri.com specifically, the request-signing key, endpoint paths, and app IDs are re-derived live from the site's own JavaScript bundles if the pinned values stop working, rather than requiring a code update for every deploy.

#### Can I use this Actor without managing proxies or browser infrastructure?

Yes. By default it connects with no proxy at all, and automatically escalates through Apify's datacenter and residential proxy tiers only if a request actually gets blocked — you don't need to configure, rotate, or pay for a proxy yourself unless you want to force a specific tier.

#### Which fields work best for AI training data and RAG indexing?

For RAG, index `description`, `shortDescription`, and `keySkills` — the highest-information text fields for semantic search. For structured training data, `jobId`, `companyId`, `salaryDetail`, `minimumExperience`/`maximumExperience`, and `createdDate` stay consistently structured across every row, all returned as typed primitives rather than strings to re-parse.

### Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| ATS Jobs API | Job postings straight from a company's own Greenhouse, Lever, Ashby, Workable, or SmartRecruiters board |
| Greenhouse Job Scraper | Every open job posting from one or more Greenhouse-hosted career pages |
| Internshala Scrapper | Internships and jobs from Internshala.com by search URL or filters |
| LinkedIn People Profile Scraper | Bulk LinkedIn people profiles — headline, experience, education, and skills |
| Linkedin Profile Scraper with Email & Company Data | LinkedIn people profiles with verified email discovery and current-company enrichment, no login required |

### Your feedback

Found a bug, or need a field this Actor doesn't return yet? Let us know — for custom solutions or feature requests, contact **dev.scraperengine@gmail.com** directly. Reports like this keep the Actor maintained as Naukri and Naukrigulf change their sites over time.

# Actor input Schema

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

🌐 One or more Naukri/Naukrigulf URLs — bulk-friendly, one per line or upload a file. Mix and match: 🔍 search/listing pages, 🏢 company-overview pages (e.g. <code>/cognizant-overview-4156?tab=jobs</code> → every open job there), and 🎯 direct job-detail pages. When this is non-empty, every field under <b>🎛️ Search by Filters</b> below is ignored.

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

⚡ Fetch these exact Naukri job IDs directly and skip search entirely — perfect for refreshing or monitoring specific postings. The ID is the digits at the end of a job URL (e.g. <code>...-091025500280</code>). When set, this overrides Start URLs and every search filter.

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

🧭 Naukri.com (India) vs Naukrigulf.com (Gulf) for filter-built search only — ignored when Start URLs or Job IDs are set.

## `searchQuery` (type: `string`):

💡 Job title, role or keyword to search for (filter mode only). Examples: <code>developer</code>, <code>data scientist</code>, <code>pharma manager</code>.

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

🏙️ City, region, or country (filter mode only). Examples: <code>bangalore</code>, <code>india</code>, <code>dubai</code>, <code>riyadh</code>. Falls back to <code>india</code> (Naukri) or <code>dubai</code> (Naukrigulf) if left blank.

## `cities` (type: `array`):

➕ Add more cities — each one runs its own search and results are merged (up to Maximum Jobs). Works together with 📍 Location above.

## `maximumJobs` (type: `integer`):

✂️ Stop after this many jobs, across every URL / city combined.

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

📊 Order results by relevance or freshness. Applies to filter-built searches and pasted search URLs.

## `experienceLevel` (type: `integer`):

📈 Minimum years of experience (filter mode).

## `jobType` (type: `string`):

🗂️ Optional, forwarded where the site supports it (e.g. Naukri's job-post-type filter).

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

🖥️ Comma-separated work-mode codes: <code>0</code> = Work from office, <code>1</code> = Temp. WFH, <code>2</code> = Remote/WFH, <code>3</code> = Hybrid. Example: <code>2,3</code> for Remote + Hybrid.

## `industry` (type: `string`):

🏗️ Single industry name or ID, matched against Naukri's live options (e.g. <code>IT Services & Consulting</code>).

## `roleCategory` (type: `string`):

🧩 Single role-category name or ID, matched against Naukri's live options.

## `companyType` (type: `array`):

🏬 Company-type names or IDs, multi-select (e.g. Product/Service/Startup), matched against Naukri's live options.

## `salaryRange` (type: `array`):

💵 Multi-select annual CTC bands. Server-side Naukri filter; jobs that hide salary are always kept.

## `department` (type: `array`):

🗃️ Naukri department / functional-area, multi-select.

## `ugCourse` (type: `array`):

📘 Required undergraduate-degree, multi-select. Jobs open to "Any Graduate" always match.

## `pgCourse` (type: `array`):

📗 Required postgraduate-degree, multi-select. Jobs open to "Any Postgraduate" always match.

## `timeFilter` (type: `string`):

📅 Only keep jobs posted within this window. Jobs with no parseable date are always kept.

## `freshnessDays` (type: `integer`):

📡 Server-side Naukri "posted in the last N days" filter (fewer rows fetched = faster & cheaper than the client-side Posted-Within filter above).

## `minSalary` (type: `integer`):

📊 Drop rows below this annual salary. Permissive: jobs with hidden/missing salary are always kept.

## `includeDescription` (type: `boolean`):

📝 Include the full HTML job description + short description in each row. Turn off for lighter, faster rows.

## `cleanHtml` (type: `boolean`):

✨ Strip HTML tags from the description fields, leaving plain readable text. Only applies when Include Full Description is on.

## `includeAmbitionBoxDetails` (type: `boolean`):

🏆 Enrich each Naukri row with the employer's AmbitionBox company rating, review count, and top reviews. Naukri.com rows only; adds a little time per row.

## `enrichEmails` (type: `boolean`):

✉️ Look up the hiring company's website and scan a few public pages (home, contact, about) for a public contact email — turns job data into a lead-gen dataset. Adds a couple of extra requests per row.

## `qualifyByPayment` (type: `boolean`):

🔍 Only meaningful together with Enrich Employer Emails. Scans the same pages for Stripe/PayPal/Shopify/etc. signatures and adds <code>takesPayments</code> / <code>paymentProcessors</code> / <code>paymentConfidence</code> to the row — a handy signal for B2B/SaaS lead qualification.

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

🌐 By default the Actor connects to Naukri/Naukrigulf with <b>NO proxy</b> for maximum speed. If a request is rejected or blocked, it automatically escalates: ⚡ No proxy → 🏢 Datacenter proxy → 🏠 Residential proxy (retried up to 3×) — then <b>sticks with Residential for every remaining request</b> in the run. Every escalation is logged clearly. You can also force a specific tier yourself here.

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

🚦 How many job pages to fetch in parallel. Higher is faster but more likely to trigger rate limiting (which the proxy ladder above then handles automatically).

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

🔄 How many times to retry a single request on a network error, rate limit, or server hiccup before giving up on it.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.naukri.com/development-programmer-jobs?k=development%2C%20programmer&nignbevent_src=jobsearchDeskGNB"
  ],
  "platform": "naukri",
  "searchQuery": "developer",
  "location": "india",
  "maximumJobs": 10,
  "sortBy": "relevance",
  "minSalary": 0,
  "includeDescription": true,
  "cleanHtml": false,
  "includeAmbitionBoxDetails": false,
  "enrichEmails": false,
  "qualifyByPayment": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxConcurrency": 10,
  "maxRequestRetries": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Job title, company, location, salary, experience and apply link for every scraped job.

## `company` (type: `string`):

Employer identity, logo, description and profile links for every scraped job.

## `compensationExperience` (type: `string`):

Salary bands and experience requirements for every scraped job.

## `skillsEducation` (type: `string`):

Role classification, required skills and education for every scraped job.

## `engagementActivity` (type: `string`):

Views, applies, vacancies and posting metadata for every scraped job.

## `enrichment` (type: `string`):

Employer email, payment-processor signals, and AmbitionBox ratings (populated only when enabled in the input).

## `fullRecord` (type: `string`):

Every one of the 41 fields, unfiltered, exactly as pushed to the dataset.

## `csv` (type: `string`):

The full result set as a CSV file.

# 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 = {
    "startUrls": [
        "https://www.naukri.com/development-programmer-jobs?k=development%2C%20programmer&nignbevent_src=jobsearchDeskGNB"
    ],
    "platform": "naukri",
    "searchQuery": "developer",
    "location": "india",
    "maximumJobs": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/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 = {
    "startUrls": ["https://www.naukri.com/development-programmer-jobs?k=development%2C%20programmer&nignbevent_src=jobsearchDeskGNB"],
    "platform": "naukri",
    "searchQuery": "developer",
    "location": "india",
    "maximumJobs": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/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 '{
  "startUrls": [
    "https://www.naukri.com/development-programmer-jobs?k=development%2C%20programmer&nignbevent_src=jobsearchDeskGNB"
  ],
  "platform": "naukri",
  "searchQuery": "developer",
  "location": "india",
  "maximumJobs": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/naukri-jobs-scraper --silent --output-dataset

```

## MCP server setup

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