Naukri API 2025: How to Programmatically Access India's Largest Job Board

Naukri.com is India’s largest job board with over 70 million registered job seekers and 70,000+ active recruiters. There is no official Naukri API for third-party access. For HR tech companies, job aggregators, and labor market researchers who need programmatic access to Naukri job data, web scraping is the only path.

TL;DR: Naukri has no public API and uses Akamai Bot Manager. Programmatic access requires session warming: visit the homepage with a stealth-patched Playwright browser to generate valid ak_bmsc cookies and capture the nkparam signed header, then use those credentials for direct JSON API calls. Indian residential proxies significantly improve success rates over US datacenter IPs.

The problem is that Naukri runs Akamai Bot Manager — one of the more sophisticated bot detection systems on the market. A naive scraper using requests or even a basic Playwright setup will get blocked within seconds. This post explains what Naukri’s bot detection actually checks for, and how to get reliable job data from it.

What Naukri’s Bot Detection Checks

Akamai Bot Manager evaluates several signals:

1. The nkparam signed header Every Naukri search request requires an nkparam header containing a signed token. This token is generated client-side by Naukri’s JavaScript and is tied to the current session, timestamp, and request parameters. Without a valid nkparam, the API returns a 406 with a “recaptcha required” message.

2. Akamai cookies (ak_bmsc, bm_sv) Akamai seeds session cookies through JavaScript challenges on page load. These cookies are used to verify that a real browser completed the challenge. Without them, requests to the search API are blocked.

3. TLS fingerprint and browser properties Akamai checks the TLS handshake fingerprint (JA3 hash) and browser properties like navigator.webdriver, the presence of browser plugins, and WebGL renderer strings. Headless Chrome with default settings fails these checks.

The Session Warming Approach

The solution is to use a real browser session with stealth modifications, then extract the session credentials for use in subsequent HTTP requests.

import { Actor } from 'apify';
import { chromium } from 'playwright-extra';
import StealthPlugin from 'puppeteer-extra-plugin-stealth';

chromium.use(StealthPlugin());

const browser = await chromium.launch({
  headless: true,
  args: ['--no-sandbox', '--disable-setuid-sandbox'],
});

const context = await browser.newContext({
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
  locale: 'en-IN',
  timezoneId: 'Asia/Kolkata',
});

const page = await context.newPage();

// Step 1: Warm the session — visit homepage to trigger Akamai challenge
await page.goto('https://www.naukri.com/', { waitUntil: 'networkidle' });

// Step 2: Human-like behavior to pass behavioral analysis
await page.mouse.move(400, 300);
await page.evaluate(() => window.scrollBy(0, 300));
await new Promise(r => setTimeout(r, 1500));

// Step 3: Intercept nkparam from the first XHR request
let nkparam = null;
page.on('request', (req) => {
  const header = req.headers()['nkparam'];
  if (header) nkparam = header;
});

// Step 4: Navigate to search — this triggers client-side rendering and XHR
await page.goto(
  `https://www.naukri.com/${keyword}-jobs`,
  { waitUntil: 'networkidle' }
);

// Step 5: If nkparam not yet captured, navigate to page 2 to force XHR
if (!nkparam) {
  await page.goto(
    `https://www.naukri.com/${keyword}-jobs?start=20`,
    { waitUntil: 'networkidle' }
  );
}

// Step 6: Extract Akamai cookies
const cookies = await context.cookies();
const akCookies = Object.fromEntries(
  cookies.filter(c => ['ak_bmsc', 'bm_sv', 'nauk_ses_id'].includes(c.name))
    .map(c => [c.name, c.value])
);

Once you have nkparam and the Akamai cookies, you can make HTTP requests directly to Naukri’s search API without the browser overhead.

Extracting Job Data

Naukri’s search API returns structured JSON at https://www.naukri.com/jobapi/v3/search:

const response = await got('https://www.naukri.com/jobapi/v3/search', {
  headers: {
    'nkparam': nkparam,
    'systemcountrycode': 'IN',
    'Cookie': Object.entries(akCookies).map(([k,v]) => `${k}=${v}`).join('; '),
    'User-Agent': 'Mozilla/5.0 ...',
  },
  searchParams: {
    noOfResults: 20,
    urlType: 'search_by_keyword',
    searchType: 'adv',
    keyword: searchKeywords,
    pageNo: pageNumber,
    seoKey: `${slug}-jobs`,
  },
});

const jobs = JSON.parse(response.body).jobDetails;

Each job object contains:

• Title, company name, and company logo
• Experience range (min/max years)
• Salary range (when disclosed)
• Location(s) — normalized city names
• Work mode (WFH, hybrid, office)
• Posted date and application count
• Job description (requires a second request per job)

Proxy Configuration

The Akamai challenge is location-aware. An Indian residential IP is significantly more likely to pass than a US datacenter IP, even with full stealth configuration. Use residential proxies with apifyProxyCountry: "IN" if running on cloud infrastructure.

Using the Managed Scraper

Building and maintaining this session-warming pipeline is complex. The nkparam token format changes occasionally, Akamai updates its fingerprint database, and residential proxy pools need rotation. Our Naukri Jobs scraper handles all of this:

from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('themineworks/naukri-jobs').call(run_input={
    'searchKeywords': 'python developer',
    'location': 'Bangalore',
    'experienceMin': 2,
    'experienceMax': 5,
    'maxJobs': 100,
    'includeJobDescription': True,
})

for job in client.dataset(run['defaultDatasetId']).iterate_items():
    print(f"{job['title']} at {job['company']} — {job['salary']}")

Data Use Cases

HR tech and ATS platforms: Naukri data powers salary benchmarking, candidate sourcing, and market rate analysis for Indian tech roles.

Labor market research: Tracking which skills appear most frequently in job postings, how salary ranges shift with experience, and which cities are hiring in which sectors.

Job aggregators: Building combined job feeds that pull from Naukri alongside LinkedIn, Indeed, and ATS job boards.

Salary intelligence: Indian tech salary data is notoriously opaque. Naukri disclosed salary data is one of the few structured sources available for India-specific compensation benchmarking.

Important Notes

Naukri’s terms of service prohibit automated scraping. Review the terms and ensure your use case complies with applicable laws before proceeding. The techniques described here are for educational purposes and legitimate data analysis.

Frequently Asked Questions

Does Naukri have an official API for accessing job data?

No. Naukri.com does not provide any official API for third-party programmatic access. All structured access to Naukri job listings requires web scraping through their public website, which is protected by Akamai Bot Manager.

What is the nkparam header and why is it required for Naukri API requests?

nkparam is a signed token Naukri’s JavaScript generates client-side for each search request, tied to the current session, timestamp, and request parameters. Requests without a valid nkparam return a 406 error with a “recaptcha required” message. The token is captured by intercepting XHR network traffic after loading the Naukri search page in a real browser.

Why do Indian residential proxies work better than US IPs for Naukri scraping?

Naukri’s Akamai Bot Manager scoring is location-aware. It treats Indian residential IPs more favorably than US datacenter IPs because Naukri is an India-centric service and its expected traffic patterns originate from Indian IP ranges. Even with full stealth configuration, a US datacenter IP scores significantly worse on Akamai’s risk model.

What job data fields does the Naukri API return?

The search API returns job title, company name and logo URL, experience range (min/max years), salary range (when disclosed, normalized to lakh INR), location in normalized city format, work mode (WFH/hybrid/office), posted date, application count, and required skills as structured fields. Full job descriptions require a separate request per job ID.

How often does the nkparam token format change on Naukri?

The nkparam token format changes with Naukri frontend deployments, typically every few months. When it changes, scrapers that hard-code the token extraction logic break until updated. This maintenance overhead is the main reason production teams opt for a managed scraper that monitors and updates automatically.