# Naukri Scraper — India Jobs, Salary & Company Ratings (`haketa/naukri-scraper`) Actor

Extract India job listings with salary data from Naukri.com — India's #1 job portal. Get salary ranges (min/max/currency), skills, experience levels, and company ratings by keyword and city. For recruitment intelligence, salary benchmarking, and Indian job market research.

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

## Pricing

from $0.70 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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.com Scraper — India Job Listings & Salary Data

Extract job listings from Naukri.com, India's #1 recruitment platform with over 50 million registered users and thousands of new jobs posted daily. Get job title, company, **structured salary ranges (min/max/currency)**, experience requirements, location, skills, full job description, employment type, and company ratings — all by keyword and city.

### What Data Does It Extract?

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Unique Naukri job identifier |
| `title` | string | Job title / position name |
| `companyName` | string | Hiring company name |
| `salary` | string | Formatted salary range (e.g. "5.0-10.0 Lacs P.A.") |
| `salaryMin` | number | Minimum salary in raw units (multiply by 100K for INR) |
| `salaryMax` | number | Maximum salary in raw units |
| `salaryCurrency` | string | Salary currency code (typically "INR") |
| `experience` | string | Required experience range (e.g. "2-5 years") |
| `location` | string | Job city / location |
| `skills` | string | Required skills and technologies, comma-separated |
| `description` | string | Full job description text |
| `employmentType` | string | Full Time, Part Time, Contract, Internship, etc. |
| `companyRating` | number | Company rating on 1-5 scale (when available) |
| `companyTags` | string | Company attributes and categories |
| `postedOn` | string | Listing publication date |
| `url` | string | Direct link to the job detail page |
| `searchKeyword` | string | The keyword that returned this job |
| `scrapedAt` | string | Extraction timestamp (ISO 8601) |

### Why This Scraper?

#### India's Largest Job Market, Fully Structured

Naukri.com is India's dominant job portal — where every major employer posts openings, from Fortune 500 companies like TCS, Infosys, Wipro, and HCL to fast-growing startups in Bengaluru, Hyderabad, and Mumbai. With millions of active listings spanning IT services, software product, BFSI, manufacturing, healthcare, retail, education, and more, Naukri is the single most comprehensive source of Indian employment data.

This scraper transforms that vast job market into clean, structured, analysis-ready JSON. No manual searching, no copy-pasting, no brittle screen scraping. Every field is parsed, normalized, and ready for your database, dashboard, or analytics pipeline.

#### Salary Intelligence That Others Miss

Salary data on Naukri lives deeper than the search results page. While basic scrapers only capture what's visible on the listing card, this scraper enriches each job with structured salary data — minimum, maximum, and currency — extracted from the full job profile. This means you can:

- **Benchmark compensation** by role, city, and experience level
- **Track salary trends** over time for the same positions
- **Compare CTC packages** across competing employers
- **Identify premium-paying companies** in any technology or domain
- **Build salary calculators** and compensation intelligence tools

The salary data is returned in raw numeric form (`salaryMin`, `salaryMax`) plus a human-readable formatted string (`salary`). One Lakh (Lac) = 100,000 Indian Rupees. A job showing "5.0-10.0 Lacs P.A." means ₹500,000 to ₹1,000,000 per annum.

#### Company Ratings & Reputation Data

Beyond just jobs, get company ratings from employee reviews. Filter for highly-rated employers, exclude low-rated companies from your recruitment targets, or track employer brand perception over time. Combine ratings with salary data to identify companies that pay well AND have happy employees.

#### Deep Skill Data

Each listing includes the full skills/technologies required — not just a tag cloud but the actual keywords employers specify. Track technology adoption trends, identify emerging skills before they hit mainstream, and understand which combinations of skills command the highest salaries.

### Use Cases

#### Recruitment & Talent Intelligence

Track real-time hiring demand across Indian cities. Understand which skills are surging and which are declining. Monitor hiring velocity by company — spot which organizations are scaling up, which are replacing talent, and which are in freeze mode.

Build talent pipelines by identifying companies that repeatedly hire for the same roles. A company posting "Python Developer" every quarter likely has retention challenges or aggressive growth — both valuable signals for recruiters.

#### Competitive Intelligence & Market Analysis

Map your competitors' hiring strategy. What roles are they filling? What salaries do they offer? Which cities are they expanding into? A competitor suddenly hiring 20+ "cloud architect" roles in Hyderabad signals a major cloud investment before any press release.

Track new market entrants. International companies entering India typically start with senior leadership hires in Mumbai or Bangalore, then scale engineering in Pune or Hyderabad. Spot these patterns weeks or months before official announcements.

#### Salary Benchmarking & Compensation Planning

Build detailed compensation benchmarks segmented by:
- **Role & seniority** — Junior Developer vs. Senior Architect vs. Engineering Manager
- **City tier** — Bangalore/Mumbai premiums vs. tier-2 city salaries
- **Company type** — MNC vs. Indian IT services vs. product startup vs. GCC
- **Technology stack** — Java vs. Python vs. Node.js vs. niche skills like COBOL or SAP

Feed structured salary data into HR analytics platforms, compensation planning tools, total rewards benchmarking, and recruitment CRM systems. Make data-driven offers that win candidates without overpaying.

#### Lead Generation for B2B Services

Every job listing is a buying signal. Companies hiring for specific roles need related services:

- **Hiring "Sales Manager"** → Needs CRM, sales training, lead generation
- **Hiring "DevOps Engineer"** → Needs cloud infrastructure, CI/CD tools, monitoring
- **Hiring "Compliance Officer"** → Needs legal/regulatory software, audit services
- **Hiring "Digital Marketing Manager"** → Needs SEO/SEM tools, content agencies, analytics
- **Hiring "HR Manager"** → Needs payroll, attendance, recruitment software

Build targeted prospect lists for SaaS companies, staffing agencies, training providers, corporate service providers, and consulting firms. Filter by industry, location, company size (inferred from hiring volume), and role seniority.

#### Academic & Policy Research

Study India's labor market with granular, real-time data:
- Employment trends by sector, geography, education level, and skill category
- Impact of economic policies (GST, labor codes, PLI schemes) on hiring patterns
- Technology adoption lifecycle — when do emerging tech roles hit tier-2 cities?
- Gender representation signals in job description language
- Remote work adoption trends across industries and cities

#### Job Boards & Aggregators

Power niche job boards and vertical search engines with fresh, structured listings. Differentiate your platform with salary transparency and company ratings. Build curated job newsletters for specific communities (e.g., "Bangalore Startup Jobs", "Women in Tech — India").

#### Investor & VC Research

Due diligence through hiring data. A startup aggressively hiring senior engineers with above-market salaries is executing well. A company that's stopped hiring and posting "replacement" roles may be struggling. Track portfolio companies' headcount trajectories through their job posting volume.

### Industry Coverage

Naukri covers virtually every sector of the Indian economy:

#### Information Technology & Services
The largest category — software developers, system architects, QA engineers, DevOps, cloud specialists, cybersecurity analysts, data engineers, AI/ML engineers, blockchain developers, and IT project managers. From TCS and Infosys to product companies and Global Capability Centers (GCCs).

#### Banking, Financial Services & Insurance (BFSI)
Relationship managers, investment bankers, financial analysts, risk managers, compliance officers, actuaries, wealth managers, loan officers, and insurance underwriters. Heavy concentration in Mumbai, with growing presence in Pune and Chennai.

#### Manufacturing & Engineering
Mechanical engineers, electrical engineers, production managers, quality control, supply chain, procurement, CNC operators, maintenance technicians, and industrial designers. Concentrated in Pune, Chennai, Ahmedabad, and Delhi-NCR's industrial belts.

#### Healthcare & Pharmaceuticals
Doctors, nurses, medical representatives, clinical research associates, pharmacists, hospital administrators, medical coders, and healthcare IT specialists. Growing across all major cities with clusters in Hyderabad (pharma) and Chennai (healthcare).

#### E-commerce & Retail
Category managers, supply chain, warehouse operations, delivery/logistics, visual merchandisers, retail store managers, and e-commerce operations. Heavy presence in Bangalore, Delhi-NCR, and Mumbai.

#### Education & EdTech
Teachers, curriculum designers, academic counselors, education technology specialists, content developers, and institutional sales. Growing in Bangalore, Delhi-NCR, and tier-2 education hubs like Kota and Jaipur.

#### Media, Entertainment & Content
Content writers, video editors, graphic designers, social media managers, SEO specialists, digital marketing managers, and creative directors. Concentrated in Mumbai, with growing clusters in Bangalore and Delhi-NCR.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchKeywords` | string[] | `["python developer"]` | Job titles, skills, or keywords to search |
| `locations` | string[] | `[]` (all India) | Target cities. Empty = nationwide search |
| `startUrls` | string[] | `[]` | Direct Naukri search/category URLs for advanced targeting |
| `maxItemsPerSearch` | integer | `100` | Maximum results per keyword + location combination |
| `maxTotalItems` | integer | `0` (unlimited) | Hard cap across all searches combined |
| `enrichSalary` | boolean | `true` | Extract structured salary data and company ratings |
| `maxEnrichConcurrency` | integer | `5` | Parallel requests for enrichment (higher = faster) |
| `proxyConfiguration` | object | `{}` | Optional Apify proxy configuration |

#### Example Input — Multi-Role Tech Scan

```json
{
    "searchKeywords": [
        "python developer",
        "java developer",
        "data scientist",
        "devops engineer",
        "react developer",
        "product manager"
    ],
    "locations": ["Bangalore", "Hyderabad", "Pune", "Mumbai"],
    "maxItemsPerSearch": 200,
    "enrichSalary": true
}
````

#### Example Input — Single Company Tracking

```json
{
    "searchKeywords": ["Tata Consultancy Services", "Infosys", "Wipro"],
    "maxItemsPerSearch": 500,
    "enrichSalary": true
}
```

#### Example Input — Startup Ecosystem Pulse

```json
{
    "searchKeywords": [
        "founding engineer",
        "early stage",
        "series a",
        "startup cto",
        "vp of engineering"
    ],
    "locations": ["Bangalore"],
    "maxItemsPerSearch": 100,
    "enrichSalary": false
}
```

### Output Example

```json
{
    "jobId": "240626008807",
    "title": "Talent Acquisition Operations Specialist",
    "companyName": "Applied Materials",
    "salary": "4.0-5.0 Lacs P.A.",
    "salaryMin": 400000,
    "salaryMax": 500000,
    "salaryCurrency": "INR",
    "experience": "3-6 years",
    "location": "Bengaluru",
    "skills": "IT Recruitment, Talent Acquisition, End to End Recruitment, Screening, Sourcing, Contract Staffing",
    "description": "IT Recruiter role responsible for end-to-end recruitment across technical positions...",
    "employmentType": "Full Time, Permanent",
    "companyRating": 3.8,
    "companyTags": "MNC, Fortune 500",
    "postedOn": "2026-06-24 10:36:12.0",
    "url": "https://www.naukri.com/job-listings-talent-acquisition-operations-specialist-240626008807",
    "searchKeyword": "applied materials software engineer",
    "scrapedAt": "2026-06-30T11:43:08.554Z"
}
```

### Tips for Best Results

#### Keyword Strategy for Indian Market

- **Indian job titles differ from Western ones** — "Software Developer" often outperforms "Software Engineer". "Delivery Manager" is common in IT services but rare elsewhere. "Fresher" and "walk-in" catch entry-level volume.
- **Combine role + technology** — "java developer", "python developer", "react developer" get more targeted results than just "developer".
- **Use company names as keywords** — search "Tata Consultancy Services", "Infosys", "Accenture" to track IT services hiring. Combine multiple MNCs in one run.
- **Niche tech commands premiums** — "sap consultant", "salesforce developer", "servicenow admin", "workday hcm" return fewer but higher-paying results.
- **Non-IT roles use different language** — "business development executive" not "sales rep". "customer care executive" not "support agent". "delivery partner" not "courier".

#### Location Targeting Deep Dive

**Tier-1 Tech Hubs (highest volume):**

- Bangalore / Bengaluru — India's Silicon Valley, highest IT job density
- Hyderabad — Microsoft, Google, Amazon GCCs + pharma hub
- Pune — IT + manufacturing, fastest growing tech market
- Chennai — IT services + manufacturing + automotive
- Mumbai — BFSI capital + media/entertainment + corporate HQs
- Delhi-NCR (includes Gurugram, Noida, Ghaziabad) — mix of tech, corporate, government

**Tier-2 Rising Stars:**

- Ahmedabad — fintech + pharma + manufacturing
- Indore — growing IT/ITES + education hub
- Jaipur — IT + tourism/hospitality + gems/jewelry
- Kochi — IT parks + spices/marine exports + tourism
- Coimbatore — manufacturing/engineering + textile + IT
- Chandigarh — IT + government + education
- Lucknow — government + education + healthcare
- Bhubaneswar — IT/ITES + government + education

**Strategy:** Leave location empty for true pan-India coverage. Otherwise, target 2-4 cities per run for cleaner regional comparisons.

#### Salary Data Interpretation

- **LPA = Lakhs Per Annum.** 1 Lakh = 100,000 INR. 10 LPA = ₹1,000,000/year ≈ $12,000 USD.
- **CTC vs. in-hand:** Naukri salaries are typically Cost-to-Company (CTC), which includes PF, gratuity, insurance, and variable pay. In-hand salary is usually 70-80% of CTC.
- **Range width matters:** A "3-8 LPA" range often means the employer is flexible on experience. A tight "12-15 LPA" suggests a specific seniority target.
- **Missing salary:** Not all listings have salary data. Jobs without structured salary will have `null` in salary fields.
- **Currency is almost always INR.** Rarely, MNCs may post in USD or EUR for niche roles. Always check `salaryCurrency`.

#### Data Quality & Coverage

- **Job descriptions** are the full text, including responsibilities, requirements, and company info
- **Skills** are the employer-specified required technologies/competencies
- **Company ratings** come from employee reviews and may not be available for very small companies
- **Employment types** include Full Time, Part Time, Contract, Temporary, Internship, Freelance
- **Posting dates** use Naukri's standard format — recent jobs may show "1 day ago", older ones have explicit dates
- **Duplicate handling** is built in — the same job won't appear twice even across multiple keywords

#### Scaling & Scheduling

- **Test small first** — run 20-50 results with your exact keywords to verify data quality before scaling to thousands
- **Multiple targeted runs > one massive run** — better to run "Bangalore Java", "Hyderabad Java", "Pune Java" as separate runs than one pan-India
- **Schedule recurring runs** — daily for high-churn roles (IT), weekly for stable roles (manufacturing, banking)
- **Enrichment trade-off** — `enrichSalary: true` takes extra time per job but gives you salary + ratings. For volume-only scans, set to `false`
- **Concurrency tuning** — `maxEnrichConcurrency: 5` is safe for most runs. Increase to 10 for faster enrichment on large runs

### Popular Search Combinations

#### IT & Software Development

| Focus | Keywords | Locations |
|---|---|---|
| Full Stack | full stack developer, mern stack developer, mean stack developer, django developer, spring boot developer | Bangalore, Hyderabad, Pune |
| Frontend | react developer, angular developer, vue js developer, ui developer, frontend developer | Bangalore, Hyderabad, Mumbai |
| Backend | java developer, python developer, node js developer, .net developer, php developer, golang developer | Bangalore, Pune, Chennai |
| Mobile | android developer, ios developer, flutter developer, react native developer, mobile app developer | Bangalore, Hyderabad, Delhi-NCR |
| Data & AI | data scientist, machine learning engineer, data engineer, nlp engineer, computer vision engineer, ai engineer, mlops engineer | Bangalore, Hyderabad, Delhi-NCR, Mumbai, Pune |
| Cloud & DevOps | devops engineer, cloud architect, aws engineer, azure engineer, gcp engineer, kubernetes engineer, terraform engineer, site reliability engineer | Bangalore, Hyderabad, Pune, Chennai |
| Cybersecurity | security analyst, penetration tester, soc analyst, information security manager, network security engineer, ethical hacker | Bangalore, Hyderabad, Delhi-NCR, Mumbai |
| QA & Testing | qa engineer, automation tester, selenium tester, performance tester, api tester, manual tester, sdet | Bangalore, Pune, Hyderabad, Chennai |
| Blockchain & Web3 | blockchain developer, solidity developer, web3 developer, smart contract developer, defi developer | Bangalore, Hyderabad, Mumbai |
| ERP & Enterprise | sap consultant, oracle consultant, salesforce developer, servicenow developer, workday consultant, microsoft dynamics consultant | Bangalore, Mumbai, Delhi-NCR, Pune |

#### Business & Management

| Focus | Keywords | Locations |
|---|---|---|
| Product | product manager, associate product manager, technical product manager, product owner, director of product | Bangalore, Mumbai, Delhi-NCR |
| Project Management | project manager, program manager, scrum master, agile coach, delivery manager, pmo | Bangalore, Mumbai, Pune |
| Business Analysis | business analyst, senior business analyst, data analyst, bi analyst, tableau developer, power bi developer | Bangalore, Mumbai, Delhi-NCR |
| Consulting | management consultant, strategy consultant, business consultant, it consultant, process consultant | Mumbai, Delhi-NCR, Bangalore |
| Operations | operations manager, supply chain manager, logistics manager, warehouse manager, procurement manager | Mumbai, Delhi-NCR, Chennai, Ahmedabad |

#### Sales, Marketing & Content

| Focus | Keywords | Locations |
|---|---|---|
| Sales | sales manager, business development manager, account executive, enterprise sales, inside sales, territory manager | Mumbai, Delhi-NCR, Bangalore |
| Digital Marketing | digital marketing manager, seo specialist, sem specialist, performance marketer, social media manager, ppc analyst | Mumbai, Delhi-NCR, Bangalore |
| Content | content writer, technical writer, copywriter, content strategist, video editor, graphic designer, ux writer | Mumbai, Bangalore, Delhi-NCR |
| Growth | growth hacker, growth marketer, demand generation, marketing automation, email marketer | Bangalore, Mumbai, Delhi-NCR |

#### Finance, Banking & Insurance

| Focus | Keywords | Locations |
|---|---|---|
| Banking | relationship manager, branch manager, credit analyst, investment banker, wealth manager, trade finance | Mumbai, Delhi-NCR, Bangalore |
| Finance | financial analyst, fp\&a, accountant, chartered accountant, auditor, tax analyst, controller | Mumbai, Delhi-NCR, Bangalore |
| Insurance | insurance underwriter, claims adjuster, actuarial analyst, insurance agent, Bancassurance | Mumbai, Delhi-NCR, Pune |
| Fintech | fintech product manager, payments engineer, risk analyst, compliance officer, kyc analyst | Bangalore, Mumbai, Hyderabad |

#### Healthcare, Pharma & Life Sciences

| Focus | Keywords | Locations |
|---|---|---|
| Healthcare | doctor, physician, nurse, medical officer, hospital administrator, radiologist, pathologist | Mumbai, Delhi-NCR, Bangalore, Chennai |
| Pharma | medical representative, clinical research associate, pharmacist, drug safety associate, regulatory affairs | Mumbai, Hyderabad, Ahmedabad |
| Medical Devices | biomedical engineer, medical device sales, service engineer, application specialist | Mumbai, Delhi-NCR, Bangalore |

#### Human Resources & Administration

| Focus | Keywords | Locations |
|---|---|---|
| HR Generalist | hr manager, hr executive, hr generalist, hr business partner, assistant hr manager | Mumbai, Delhi-NCR, Bangalore |
| Talent Acquisition | recruiter, talent acquisition specialist, technical recruiter, campus recruiter, sourcing specialist | Bangalore, Mumbai, Delhi-NCR |
| HR Specialized | compensation benefits manager, learning development manager, hr analytics, payroll manager, hr operations | Mumbai, Bangalore, Delhi-NCR |
| Administration | office administrator, executive assistant, front office executive, facility manager, admin executive | Mumbai, Delhi-NCR, Bangalore |

### Frequently Asked Questions

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

There's no hard limit — Naukri has millions of active listings. A single keyword + city combination can return thousands of results. Use `maxItemsPerSearch` and `maxTotalItems` to control volume. For large-scale extraction, run multiple targeted searches rather than one broad query.

#### Do I need proxies?

For small to medium runs (under 500 jobs), proxies are typically not needed. For large-scale or continuous extraction, Indian datacenter or residential proxies improve reliability and throughput.

#### Is salary data available for every job?

No. Not all employers disclose salary on Naukri. Salary availability varies by industry, company size, and role type. IT and tech roles tend to have higher salary disclosure rates. When salary is unavailable, the `salary`, `salaryMin`, `salaryMax`, and `salaryCurrency` fields will all be `null`.

#### Can I search by company name?

Yes. Enter company names as `searchKeywords` — "Tata Consultancy Services", "Infosys", "Google", "Microsoft". Combine multiple companies in one run to compare their hiring patterns side by side.

#### What's the difference between `salary` and `salaryMin`/`salaryMax`?

`s salary` is a human-readable formatted string ("5.0-10.0 Lacs P.A.") for display. `salaryMin` and `salaryMax` are raw numeric values (500000, 1000000) for calculations, filtering, and analytics. Use the numeric fields for salary benchmarking and the formatted field for user-facing output.

#### Does this cover remote jobs?

Yes. Remote and work-from-home jobs are included when they target Indian candidates. Some remote jobs list "Remote" or "WFH" in the location field. To specifically find remote jobs, use "remote" or "work from home" in your keyword search.

#### How fresh is the data?

Data is extracted in real-time when you run the scraper. `postedOn` shows when the job was published on Naukri. Schedule regular runs to track new listings and changes over time.

#### Can I export to CSV/Excel?

Yes. Apify supports exporting dataset results to CSV, Excel, JSON, XML, and other formats directly from the platform. Use Apify's built-in export tools or integrate with Google Sheets, Airtable, or your database via Apify integrations.

### Legal & Responsible Use

This scraper extracts publicly available job listings from Naukri.com. The data is intended for legitimate purposes including recruitment intelligence, job market research, competitive analysis, compensation benchmarking, academic research, and B2B lead generation.

**Best practices:**

- Extract only the data you need for your specific use case
- Respect rate limits and Naukri's terms of service
- Use extracted data for analysis, research, and internal tools
- Do not republish or redistribute listings without appropriate licensing
- Follow applicable Indian data protection, privacy, and labor laws
- Consult legal counsel for questions about specific use cases or compliance requirements

***

*For questions, feature requests, or custom extraction needs, reach out through the Apify platform.*

🤖 Generated with [Claude Code](https://claude.com/claude-code)

### 📅 Changelog & Maintenance

**Last updated:** 2026-07-02 — Actor verified and maintained. Data pipeline tested for quality, structure and freshness; selectors/endpoints confirmed against the live site.

# Actor input Schema

## `searchKeywords` (type: `array`):

Job keywords to search on Naukri, e.g. 'python developer', 'data scientist', 'marketing'. Each keyword runs a separate search.

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

City/location filters, e.g. 'Bangalore', 'Mumbai', 'Delhi NCR'. Leave empty for all India.

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

Direct Naukri search URLs to scrape.

## `maxItemsPerSearch` (type: `integer`):

Max jobs per keyword. Default 100.

## `maxTotalItems` (type: `integer`):

Global cap. 0 = unlimited.

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

Naukri rate-limits non-India IPs. India proxy recommended for scale.

## `enrichSalary` (type: `boolean`):

Fetch each job's detail page for structured salary data (min/max) and company ratings. Slower but gives richer data.

## Actor input object example

```json
{
  "searchKeywords": [
    "java developer",
    "data analyst"
  ],
  "locations": [
    "Bangalore",
    "Pune"
  ],
  "maxItemsPerSearch": 20,
  "maxTotalItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "enrichSalary": true
}
```

# Actor output Schema

## `jobId` (type: `string`):

Naukri job ID

## `title` (type: `string`):

Job title/position

## `companyName` (type: `string`):

Company/hiring organization

## `companyRating` (type: `string`):

AmbitionBox company rating (1-5)

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

Salary range/CTC

## `salaryMin` (type: `string`):

Minimum annual salary

## `salaryMax` (type: `string`):

Maximum annual salary

## `salaryCurrency` (type: `string`):

Salary currency code

## `experience` (type: `string`):

Required experience (years)

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

Job location/city

## `skills` (type: `string`):

Required skills/technologies

## `employmentType` (type: `string`):

Full Time, Part Time, etc.

## `description` (type: `string`):

Job description snippet

## `postedOn` (type: `string`):

Job posting date

## `url` (type: `string`):

Job detail page URL

## `searchKeyword` (type: `string`):

Keyword used for search

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "searchKeywords": [
        "python developer"
    ],
    "locations": [],
    "maxItemsPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "searchKeywords": ["python developer"],
    "locations": [],
    "maxItemsPerSearch": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri Scraper — India Jobs, Salary & Company Ratings",
        "description": "Extract India job listings with salary data from Naukri.com — India's #1 job portal. Get salary ranges (min/max/currency), skills, experience levels, and company ratings by keyword and city. For recruitment intelligence, salary benchmarking, and Indian job market research.",
        "version": "0.1",
        "x-build-id": "hkD6rH6hEmLtgmZfE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~naukri-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-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/haketa~naukri-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-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/haketa~naukri-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-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": {
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Job keywords to search on Naukri, e.g. 'python developer', 'data scientist', 'marketing'. Each keyword runs a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "City/location filters, e.g. 'Bangalore', 'Mumbai', 'Delhi NCR'. Leave empty for all India.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Naukri search URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerSearch": {
                        "title": "Max items per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Max jobs per keyword. Default 100.",
                        "default": 100
                    },
                    "maxTotalItems": {
                        "title": "Max total items",
                        "type": "integer",
                        "description": "Global cap. 0 = unlimited.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Naukri rate-limits non-India IPs. India proxy recommended for scale.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "enrichSalary": {
                        "title": "Enrich salary & rating",
                        "type": "boolean",
                        "description": "Fetch each job's detail page for structured salary data (min/max) and company ratings. Slower but gives richer data.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```