# Naukri Jobs Scraper (India) (`nice_dev/naukri-jobs-scraper`) Actor

Scrape Naukri.com job listings in India: salary, skills, experience, company, full description, walk-in details and AmbitionBox ratings. Up to 15,000 jobs per search, every Naukri filter by name. JSON, CSV, Excel.

- **URL**: https://apify.com/nice_dev/naukri-jobs-scraper.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** Jobs, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.07 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### 💼 What is Naukri Jobs Scraper?

**Naukri Jobs Scraper** extracts **job listings from [Naukri.com](https://www.naukri.com)**, India's largest job site: **job title, company, salary, experience, location, skills, posting date, walk-in details and AmbitionBox ratings**, and on request the **full job description, education, applicants and views, AmbitionBox salary and interview questions**. It works as a **Naukri API alternative**: run it on a schedule, call it from your code, or plug it into Make, Zapier or n8n.

Type a **keyword** (`python developer`) and a **city** (`Bangalore`), or paste any Naukri search URL, click **Start**, and download the jobs in JSON, CSV or Excel. No Naukri account, nothing to set up. One search returns **up to 15,000 jobs**, and bigger searches are split automatically to go further.

### 📋 What data can you extract from Naukri?

One item per job, 125 fields:

| Category | What you get |
| --- | --- |
| 🏷️ **Job** | title, link, Naukri job id, number of openings, promoted or not — `Data Engineer` |
| 🏢 **Company** | name, logo, Naukri company id, consultant or direct employer, client of the consultant — `Tech Mahindra` |
| 💰 **Salary** | text as shown, yearly min and max in rupees and in lakhs, hidden or not — `15-25 Lacs P.A.` |
| 🎓 **Experience and education** | years asked (min, max), graduate and post-graduate degrees asked — `4-9 Yrs` |
| 📍 **Location and work mode** | cities, areas, office / remote / hybrid — `Chennai, Bengaluru` |
| 🧰 **Skills and description** | key skills, short description, full description as text and HTML, highlights |
| 🗂️ **Role** | role, role category, department, industry, employment type — `Software Development` |
| 🕒 **Dates and activity** | posting date, age as shown, applicants and views so far |
| 🚶 **Walk-in drives** | dates, timing, venue, map link, contact name and phone |
| ⭐ **AmbitionBox** | company rating and reviews count, recent employee reviews, typical salary for the role, benefits, interview questions |
| 🏛️ **Company page** (option) | company type, year founded, size, headquarters, offices, followers, ratings by topic, salaries by role |
| ✉️ **Company contacts** (option) | e-mail addresses, phone numbers and social links found on the company's own website |
| 🎒 **Internships** | stipend, duration, start date, deadline, perks |
| 📨 **Apply** | employer's own apply link, careers page, reference code, e-mails and phones written in the ad |

Every field, with an example, is listed in the **Output** section below.

Fields marked **detail** in the Output tab (full description, education, applicants and views, role and industry, AmbitionBox salary, benefits and interview questions, e-mails and phones written in the ad…) are filled when **Extract details** is on. It is off by default: the results list alone already gives title, company, salary, experience, location, skills, posting date, walk-in details and the AmbitionBox rating.

### ✅ Why use Naukri Jobs Scraper?

- 📈 **Up to 15,000 jobs per search**, and searches above that are split automatically into smaller parts to go further.
- 🎯 **Every Naukri filter, by name**: experience, salary in lakhs, freshness, work mode, industry, department, role category, company type, degree, company, internship stipend and duration. Type `Banking` or `IT Services & Consulting`, no id to look up.
- 📍 **Location as text**: `Bangalore`, `Delhi NCR`, `Remote`, no city id needed.
- 🧹 **More filters than Naukri itself**: posting date range, keywords to include or exclude, companies to exclude, experience asked, salary, company rating, walk-in drives only (or none), only jobs with a salary, a phone or an e-mail, only jobs applied for on Naukri.
- 🔔 **Monitoring built in**: tick **Only new jobs**, schedule the Actor, and each run returns (and charges) only the jobs it has never delivered before.
- 🗂️ **Several searches in one run**: keywords × locations, with a cap per search, each job returned once.
- 📊 **Market statistics** (option): Naukri's own counts for the whole search — jobs by salary band, city, work mode, industry, top hiring companies.
- 🔌 API, scheduling, integrations (Make, Zapier, n8n, Google Sheets…) and JSON/CSV/Excel export via the Apify platform.

### 🚀 How to scrape Naukri

1. Create a free Apify account.
2. Open **Naukri Jobs Scraper**, type **Search keywords** (e.g. `python developer`) and a **Location** (e.g. `Bangalore`), and set the Naukri filters you want.
3. Or paste your own Naukri URLs into **Start URLs** (any search results page, with its filters, or single job pages), or job ids into **Job ids**.
4. Set **Max jobs** (100 by default, 0 = no limit) — and **Max jobs per search** when you run several searches — then click **Start**.
5. Download the dataset in JSON, CSV, Excel or via API.

### 💰 How much does it cost to scrape Naukri?

This Actor uses **pay per event** pricing: you pay for the jobs you get, and the exact prices for your Apify plan are shown in the **Pricing** tab. Platform usage (compute, proxy) is included.

- **`result`**: each job saved from the results list.
- **`result-with-details`**: each job saved with its full job page (**Extract details** on, or a job pasted by URL or id) — one price for the job, details included, not on top of `result`.
- **`market-stats`** (option, off by default): each search sheet of **Add market statistics per search**.
- **`company-details`** (option, off by default): each company whose Naukri page is read with **Add company details**, once per run; a company without a page is never charged.
- **`email-enriched`** (option, off by default): once per company and per run, where **E-mails from the company website** finds an e-mail address, on top of the job's price; the phone numbers and social links found on the same pages come with it; a company where no e-mail is found costs nothing.
- A small fee per **run start**.
- Filters Naukri does not offer are applied by the Actor on every job it reads: a job you keep costs its normal price, a job a filter drops costs only a small filter fee (`filter-check`, or `detail-filter-check` when the filter needs the job page) — filtering never costs more than taking everything.

### ⚙️ Input

```json
{
    "query": "python developer",
    "location": "Bangalore",
    "experience": 3,
    "workMode": ["remote", "hybrid"],
    "maxItems": 200
}
```

Several searches, a cap per search, only recent jobs, only the ones not delivered before:

```json
{
    "searchQueries": ["data engineer", "java developer"],
    "locations": ["Bangalore", "Pune", "Hyderabad"],
    "maxItemsPerQuery": 50,
    "postedAfter": "7 days",
    "onlyNew": true,
    "stateKey": "tech-india"
}
```

Or with your own URLs and job ids:

```json
{
    "startUrls": [
        { "url": "https://www.naukri.com/python-developer-jobs-in-bangalore?experience=3" },
        {
            "url": "https://www.naukri.com/job-listings-data-engineer-bangalore-chennai-tech-mahindra-chennai-bengaluru-4-to-9-years-141026037377"
        }
    ],
    "jobIds": ["160126029546"],
    "maxItems": 500
}
```

| Field | Notes |
| --- | --- |
| `query`, `searchQueries` | Job title, skill, designation or company, as typed in the Naukri search box (`python developer`, `sales`, `walkin`); `searchQueries` adds more keywords (one search each). Empty = every job of the location and Naukri filters. With no keyword, no location, no Naukri filter and no start URL or job id, the run is a small example (`python developer` in Bangalore, 20 jobs at most): the Actor's own filters (dates, salary, excluded words…) are not a search on their own. |
| `location`, `locations` | City or area as typed on Naukri (`Bangalore`, `Delhi NCR`, `Pune`, `Remote`); `locations` adds more places. Every keyword is searched in every location (max 500 searches per run). Empty = all India. |
| `startUrls` | Naukri search results pages (`https://www.naukri.com/python-developer-jobs-in-bangalore?experience=3`: keyword, location and filters of the URL kept, pagination automatic) or single job pages. Up to 1,000 URLs. When set, the search fields are ignored; filters, caps and monitoring still apply. |
| `jobIds` | Naukri job ids, the 12 digits at the end of a job URL (`160126029546`), read like pasted job pages. |
| `maxItems`, `maxItemsPerQuery` | Most jobs for the whole run, and for EACH search (keyword × location, or search URL). `0` = no limit. |
| `experience` | Your experience in years: Naukri keeps the jobs whose range includes it (`5`). |
| `freshness` | Jobs posted in the last `1`, `3`, `7`, `15` or `30` days (Naukri's own filter). |
| `workMode` | `office`, `remote`, `hybrid` (several = any of them). |
| `salaryRanges` | Naukri salary bands in lakhs per year: `0to3`, `3to6`, `6to10`, `10to15`, `15to25`, `25to50`, `50to75`, `75to100`, `100to500`, `501` (5+ crore). |
| `sortBy` | `relevance` (default) or `date`. With `maxItems`, `date` gives the newest jobs of a search of up to 15,000 jobs; a bigger search is read in parts, each newest first: the jobs kept are recent, not exactly the newest of the whole search. |
| `postedBy` | `any`, `company` (the employer itself) or `consultant` (recruitment agencies). |
| `industries`, `roleCategories` | Names as Naukri shows them (`IT Services & Consulting`, `Banking`) or Naukri ids (`109`). Case ignored; an unknown name stops the run before anything is charged and shows the closest names. |
| `companyTypes`, `departments`, `ugCourses`, `pgCourses` | Company type (Startup, Indian MNC, Foreign MNC, Govt/PSU…), department, graduate and post-graduate degree asked: pick them in the form. |
| `companyGroupIds` | Only the jobs of these companies, by Naukri company id (`10476` = Accenture, `13832` = Infosys) — the **groupId** column of any result. |
| `stipends`, `internshipDurations` | Internships only: stipend per month (`unpaid`, `10To20`…) and duration in months. |
| `extractDetails` | Open each job page: full description, all key skills, education, applicants and views, role, department, industry, company description and address, e-mails and phones written in the ad, AmbitionBox reviews, salary, benefits and interview questions. Off by default (charged as a job with details). |
| `includeMarketStats` | One sheet per search in the **MARKET_STATS** record of the run's key-value store: Naukri's counts for the WHOLE search (total, salary bands, cities, work mode, industries, top hiring companies, degrees…), no extra page read. With `maxItems`, the run stops reading at its cap: the searches not read by then have no sheet, and no charge (500 sheets per run at most). Off by default. |
| `includeCompanyDetails` | Read the Naukri page of each hiring company once per run: type, founded, size, headquarters, offices, followers, ratings by topic, benefits, salaries by role. Only large companies have one. Off by default. |
| `enrichEmails` | Visit each company's own website (home page, contact and legal pages, 3 pages max, once per company per run) for its e-mail addresses, phone numbers and social links. Needs **Extract details** or job ids. The website is read from the job page, the company block of the job or the company page (**Add company details**); a company that publishes none goes out without contacts. Charged once per company where an e-mail is found (see Pricing); a company with no e-mail costs nothing. |
| `postedAfter`, `postedBefore` | Posting date range: `2026-09-01`, or a period before now (`7 days`, `2 weeks`, `1 month`, `24 hours`). |
| `excludeKeywords`, `includeKeywords` | Drop the jobs whose title contains one of these texts (`trainee`, `night shift`; a text inside a longer word counts too: `intern` also drops "International Sales"); keep only the jobs whose title, skills or short description contain one of them. Case and accents ignored. |
| `excludeCompanies` | Drop the jobs of companies whose name contains one of these words (`staffing`). |
| `experienceMin`, `experienceMax` | Experience the job asks for, in years: its range must reach the minimum (`5`) and start at or below the maximum (`0` = fresher jobs). |
| `walkInOnly`, `excludeWalkIns` | Keep only the walk-in interview drives, or drop them. |
| `walkInWithinDays` | Walk-in drives still open today or starting within this many days (`0` = today, `7` = this week). |
| `onlyWithSalary` | Keep only the jobs that show their salary (most Naukri jobs hide it). |
| `minSalaryLakhs`, `maxSalaryLakhs` | Shown salary, in lakhs per year (`8.5`); jobs with a hidden salary are dropped. |
| `minCompanyRating` | Minimum AmbitionBox rating of the company, out of 5 (`3.5`). |
| `requirePhone`, `requireEmail`, `naukriApplyOnly` | Only jobs with a phone number, only jobs with an e-mail in the description (needs `extractDetails`), only jobs applied for on Naukri. |
| `onlyNew`, `stateKey`, `resetState` | Monitoring: only the jobs never delivered under this memory key; `resetState` forgets the memory. |
| Advanced | `proxyConfiguration` (Apify proxy by default, included in the price; the residential proxy is not available), `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog`. |

### 📦 Output

One job found by the search `python developer` in `Bangalore`, with **Extract details** on (shortened: empty and long fields cut):

```json
{
    "id": "141026037377",
    "url": "https://www.naukri.com/job-listings-data-engineer-bangalore-chennai-tech-mahindra-chennai-bengaluru-4-to-9-years-141026037377",
    "title": "Data Engineer - Bangalore & CHennai",
    "companyName": "Tech Mahindra",
    "companyId": 100007,
    "groupId": 2114,
    "companyLogo": "https://img.naukimg.com/logo_images/groups/v1/2114.gif",
    "isConsultant": false,
    "isTopGroup": true,
    "location": "Chennai, Bengaluru",
    "locations": ["Chennai", "Bengaluru"],
    "localities": [],
    "locationIds": ["97", "183"],
    "country": "IN",
    "experienceText": "4-9 Yrs",
    "experienceMin": 4,
    "experienceMax": 9,
    "salaryText": "15-25 Lacs P.A.",
    "salaryMin": 1500000,
    "salaryMax": 2500000,
    "salaryCurrency": "INR",
    "salaryPeriod": "year",
    "salaryMinLakhs": 15,
    "salaryMaxLakhs": 25,
    "salaryHidden": false,
    "skills": ["Pyspark", "Big Data", "Rest API Development", "Python", "SQL"],
    "preferredSkills": ["Pyspark", "Big Data", "Rest API Development", "Python", "SQL"],
    "descriptionSnippet": "Data Engineer, 4 to 10 years, Bangalore & Chennai. Python, Pyspark, Big Data, REST API development…",
    "highlights": [],
    "publishedAt": "2026-10-14T12:32:48.000Z",
    "postedAgo": "1 Day Ago",
    "vacancies": 1,
    "applicants": 641,
    "views": 688,
    "workMode": "office",
    "employmentType": "Full Time, Permanent",
    "isInternship": false,
    "internshipPerks": [],
    "roleCategory": "Software Development",
    "roleCategoryId": "1028",
    "jobRole": "Data Engineer",
    "department": "Engineering - Software & QA",
    "industry": "IT Services & Consulting",
    "educationUg": ["Any Graduate"],
    "educationPg": [],
    "educationDoctorate": [],
    "educationSchool": [],
    "companyPageUrl": "https://www.naukri.com/tech-mahindra-overview-2114",
    "companyTags": [],
    "companyAwards": [],
    "companyBenefits": [],
    "companyRatings": [],
    "companyMediaUrls": [],
    "companyOffices": [],
    "companySalaries": [],
    "companyEmails": [],
    "companyEmailKind": null,
    "companyEmailSource": null,
    "companyPhones": [],
    "companySocialLinks": [],
    "applyUrl": null,
    "listingMode": "posted",
    "emails": [],
    "phones": [],
    "isWalkIn": false,
    "tags": [],
    "ambitionBoxRating": 3.3,
    "ambitionBoxReviewsCount": 47379,
    "ambitionBoxUrl": "https://www.ambitionbox.com/reviews/tech-mahindra-reviews",
    "ambitionBoxReviews": [
        {
            "title": "Data Engineer in Bengaluru",
            "rating": 3,
            "likes": "There is no good thing here specially for freshers.",
            "dislikes": "Average for experienced folks…",
            "author": "Anonymous",
            "publishedOn": "04 Sep 2025",
            "url": "https://www.ambitionbox.com/reviews/tech-mahindra-reviews?rid=73479822"
        }
    ],
    "ambitionBoxSalary": {
        "jobProfile": "Data Engineer",
        "averageLakhs": 7.8,
        "minLakhs": 7.4,
        "maxLakhs": 8.2,
        "url": "https://www.ambitionbox.com/salaries/tech-mahindra-salaries/data-engineer"
    },
    "ambitionBoxBenefits": ["Learning & Development Support", "Health Insurance", "Health & Wellness Support"],
    "ambitionBoxInterviewQuestions": [
        "Explain Machine Learning methods.",
        "What are the differences between ELT and ETL, and can you provide an example of each?"
    ],
    "searchKeyword": "python developer",
    "searchLocation": "Bangalore",
    "searchUrl": "https://www.naukri.com/python-developer-jobs-in-bangalore?k=python+developer&l=Bangalore",
    "source": "naukri.com",
    "leadScore": 70,
    "leadSignals": [
        "direct",
        "fresh",
        "salary",
        "company",
        "verified",
        "fewApplicants"
    ],
    "scrapedAt": "2026-10-15T08:00:00.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

#### All 125 fields

| Fields | What you get |
| --- | --- |
| `id`, `url`, `title` | **Job**: Naukri job id, public job page, title |
| `companyName`, `companyId`, `groupId`, `companyLogo`, `companyJobsUrl` | **Company**: name, Naukri ids (`groupId` = input **Companies (Naukri ids)**), logo, page with all the company's jobs |
| `hiringFor`, `isConsultant`, `hiringForGroupId`, `hiringForLogo` | the client named by a recruitment consultant, and whether a consultant posted the job |
| `isTopGroup`, `isPromoted`, `isKycVerified` | top company on Naukri (detail), paid promoted job, employer identity verified (detail) |
| `location`, `locations`, `localities`, `locationIds`, `country` | **Location**: cities as text and as a list, areas (detail), Naukri city ids (detail), `IN` |
| `experienceText`, `experienceMin`, `experienceMax` | **Experience** asked: `4-9 Yrs`, `4`, `9` |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | **Salary**: as shown (`Not disclosed` when hidden), yearly min and max, `INR`, `year` — null when hidden |
| `salaryMinLakhs`, `salaryMaxLakhs`, `salaryHidden`, `salaryVariablePercent` | the same in lakhs per year, hidden or not, share of variable pay |
| `skills`, `preferredSkills` | key skills (all of them with details), preferred skills (detail) |
| `descriptionSnippet`, `highlights`, `description`, `descriptionHtml` | first lines from the results list; highlights, full description as text and HTML (detail) |
| `publishedAt`, `postedAgo` | **Dates**: posting date in ISO 8601 UTC (what the date filters read), age as shown (`1 Day Ago`; empty for internships, which show their start date: `internshipStart`, and for a job read by **Job ids** or a job page address) |
| `vacancies`, `applicants`, `views` | openings, applications and views so far (detail) |
| `workMode`, `employmentType`, `jobType` | `office`, `remote` or `hybrid`; `Full Time, Permanent`; `fulltime` or `internship` |
| `isInternship`, `internshipStipend`, `internshipStipendText`, `internshipStipendCurrency` | **Internships**: monthly stipend as a number and as shown |
| `internshipDuration`, `internshipDurationMonths`, `internshipStart`, `internshipApplyBy`, `internshipPerks` | duration and start (deadline and perks: detail) |
| `roleCategory`, `roleCategoryId`, `jobRole`, `department`, `industry` | **Role**: `Software Development`, `1028`, `Data Engineer`, department, `IT Services & Consulting` (detail; `roleCategoryId` is empty for a job read by **Job ids** or a job page address) |
| `educationUg`, `educationPg`, `educationDoctorate`, `educationSchool`, `educationCombination` | **Education** asked: degrees, 10th / 12th, how they combine (`UG or PG`) (detail) |
| `companyDescription`, `companyAddress`, `companyWebsite`, `companyPageUrl` | about the company, address, website (job page, company block of the job, or company page with **Add company details**), Naukri company page (detail) |
| `companyHeadquarters`, `companyFollowers`, `companyTags`, `companyAwards` | **Company page** (option **Add company details**, or the company block of a branded job): headquarters, followers, tags, awards |
| `companyBenefits`, `companyRatings`, `companyMediaUrls` | benefits reported, employee ratings by topic, company photos and videos |
| `companyType`, `companyFounded`, `companySize`, `companyOverallRating`, `companyReviewsCount` | `Public` / `Private`, year founded, size band, overall rating and reviews count (option **Add company details**) |
| `companyOffices`, `companySalaries` | offices (city, address, headquarters or not, coordinates), salaries by role in lakhs (option **Add company details**) |
| `brandingBannerUrl`, `isBranded` | banner and flag of a branded (premium) job page (detail) |
| `applyUrl`, `careersUrl`, `referenceCode`, `hasScreeningQuestions`, `listingMode` | **Apply**: employer's own apply page, careers page, employer's reference, questions asked when applying (empty for a job read by **Job ids** or a job page address), `posted` or `crawled` |
| `emails`, `phones` | e-mail addresses and phone numbers written in the job description (detail) |
| `companyEmails`, `companyEmailKind`, `companyEmailSource` | **Company website** (option **E-mails from the company website**): e-mail addresses published on the company's own website, the kind of the first one (`role` such as hr@ or careers@, `generic` such as info@, `personal`) and the page where it was found |
| `companyPhones`, `companySocialLinks` | phone numbers and social network pages found on the same pages (option **E-mails from the company website**; free with it) |
| `isWalkIn`, `walkInStartDate`, `walkInEndDate`, `walkInTiming` | **Walk-in drives**: first and last day (`YYYY-MM-DD`), timing |
| `walkInSaturday`, `walkInSunday`, `walkInVenue`, `walkInMapUrl` | open on Saturday / Sunday, venue address, Google Maps link |
| `walkInContactName`, `walkInContactPhone` | person to meet or call, as given in the walk-in block |
| `tags`, `diversityPreference` | Naukri tags of the job (`women`, `diversity`…), diversity note |
| `ambitionBoxRating`, `ambitionBoxReviewsCount`, `ambitionBoxUrl`, `ambitionBoxReviews` | **AmbitionBox**: company rating out of 5, reviews count, reviews page, recent employee reviews (detail) |
| `ambitionBoxSalary`, `ambitionBoxBenefits`, `ambitionBoxBenefitsReportedBy`, `ambitionBoxBenefitsUrl` | typical yearly salary for this role at this company, benefits and how many employees reported them (detail) |
| `ambitionBoxInterviewQuestions` | interview questions reported for this role (detail) |
| `searchKeyword`, `searchLocation`, `searchUrl` | the search that found the job (null for pasted job URLs and ids) |
| `source`, `scrapedAt` | `naukri.com`, ISO timestamp of the extraction |
| `leadScore`, `leadSignals` | **Lead score** for a recruitment agency, 0 to 100, free and computed from the row's own fields: is the company hiring actively and can it be reached? Points: `direct` 20 (posted by the employer, not a consultancy), `phone` 20 (a phone number in the job text or the walk-in contact), `manyOpenings` 15 (2 vacancies or more), `fresh` 15 (published 7 days or less before the run), `salary` 10 (salary shown), `company` 10 (company named), `verified` 5 (company verified by Naukri), `fewApplicants` 5 (fewer than 50 applicants). `phone`, `verified` and `fewApplicants` need the job page (**Extract details**). `leadSignals` lists the ones the job has. |

### 💡 Tips

#### How to get more results

One Naukri search gives up to 15,000 jobs. Above that, the Actor splits the search automatically into smaller searches and reads each of them, to go beyond 15,000 jobs (a search such as all jobs in Pune counts more than 60,000). Set `maxItems` to `0` for no cap, or use several keywords and locations.

#### How to reduce costs

The price is per job, so the levers are `maxItems`, `maxItemsPerQuery`, the Naukri filters (free: Naukri only returns the matching jobs), the Actor's own filters (a dropped job costs only the filter fee) and `onlyNew` for recurring runs (you never pay twice for the same job). Leave **Extract details** off when the results-list fields are enough: a job with its full page costs more than a job from the list.

#### Several searches in one run

Fill `searchQueries` and / or `locations`: the Actor runs one search per keyword × location (3 keywords × 4 cities = 12 searches, up to 500 per run). The single `query` and `location` fields still work and are added to the lists. A job found by several searches is saved — and charged — once. Set `maxItemsPerQuery` to give every search its own cap: without it the first searches can use up the whole `maxItems` budget. You can also paste several search URLs into `startUrls`: each one is a search of its own, with the same cap.

#### Monitoring: only the new jobs

Tick **Only new jobs** (`onlyNew`) and schedule the Actor. The first run returns everything; each later run skips the jobs already delivered: they are not saved, not charged and, for jobs found by a search, their page is not even opened. The memory lives in a named key-value store of your account (`naukri-jobs-scraper-seen`, up to 150,000 jobs per key) and is only updated with jobs that really reached the dataset, so a failed run never hides anything. Give each schedule its own `stateKey` (two schedules sharing a key would hide each other's jobs), and tick `resetState` once to start over. Searches are then read newest first, and a search stops once it meets a long run of jobs you already have (promoted jobs pinned at the top are not counted).

#### Filter by posting date

`postedAfter` and `postedBefore` take a date (`2026-09-01`, the whole day is included) or a period before now (`7 days`, `2 weeks`, `1 month`; via the API also `24 hours` or a full ISO date-time). The filter reads `publishedAt`; a job without a posting date is dropped as soon as a date bound is set. Naukri gives no posting date to internships on its results list: without **Extract details** a date bound drops them (no filter fee, one warning in the log); with **Extract details** the job page dates them and the filter judges it. Filtered-out jobs are not saved and do not count in `maxItems` (each job dropped costs the filter fee, see Pricing); the run summary tells how many were filtered. With `postedAfter`, searches are read newest first and stop at the first page that is entirely too old. For the last 1 to 30 days, Naukri's own **Freshness** filter is free.

#### Walk-in drives

Use the keyword `walkin` with **Walk-in drives only**: each walk-in job comes with its dates, timing, venue, map link and contact, straight from the results list. **Walk-in within the next N days** keeps the drives you can still attend.

### 🔌 Integrations and API

Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per Naukri job. Actor id: `nice_dev/naukri-jobs-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/naukri-jobs-scraper`.

Smallest input, for a cheap first call:

```json
{
    "query": "python developer",
    "location": "Bangalore",
    "maxItems": 10
}
```

Key output fields: `url`, `title`, `companyName`, `salaryText`, `experienceText`, `location`, `skills`, `publishedAt`, and `description` (with `extractDetails`).

Cost: pay per event — per job saved (`result`, or `result-with-details` with the full job page) plus a small fee per run start, see the pricing section above and the **Pricing** tab. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape Naukri?

The Actor only reads what Naukri shows publicly to any anonymous visitor. It logs in to nothing and needs no Naukri account. Results can contain personal data (the contact person of a walk-in drive, e-mails and phone numbers written in a job ad), which is protected by laws such as the GDPR and India's Digital Personal Data Protection Act: do not store or use it without a legitimate reason. You are responsible for using the data in compliance with Naukri's Terms of Use and applicable law. This Actor is not affiliated with Naukri.com or Info Edge.

#### Does it give the recruiter's e-mail or phone number?

Naukri does not show the recruiter's contact on its job pages. The Actor returns the contact of walk-in drives (name and phone, as Naukri shows them) and, with **Extract details**, the e-mail addresses and phone numbers written by the employer in the job description, when there are any.

#### Where do the company e-mail addresses come from?

With **E-mails from the company website** on, the Actor reads the pages each company publishes on its own website (home page, contact page, legal notice) and returns the business contact addresses shown there — what any visitor sees. It does not log in, guess addresses, read contact forms or bypass any protection. Some of these addresses are personal data under GDPR (e.g. `firstname.lastname@company.com`): you are responsible for having a lawful basis before using them, for informing the people concerned and for honouring opt-outs. Rules for B2B e-mail prospecting differ by country (opt-out in some, prior consent in others).

**And the phone numbers?** The Actor also returns the phone numbers the company publishes on those same pages (`tel:` links, the company's structured data, numbers written next to a "phone" label or in international form). It never guesses a number, never dials, sends no message and reads nothing that is not shown to any visitor. A number can be personal data (a sole trader's mobile): the same responsibilities apply, and rules on phone prospecting (opt-out registers, prior consent in some countries) differ by country.

#### Does it need a login or a proxy?

No login. The proxy is included in the price: leave the default setting (the residential proxy is not available). A request the site turns away is retried at once on a new proxy session, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds).

#### Is the data safe to open in Excel or to show on a web page?

Titles and descriptions are the employers' own words, copied as they are. A text can begin with `-`, `+`, `=` or `@` (a phone number such as `+91…`, a title): Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. `descriptionHtml` is the employer's HTML, not sanitized: on a web page, escape every field like any text written by a stranger.

#### Known limitations

- Most Naukri jobs hide their salary: `salaryMin` / `salaryMax` are then null and `salaryHidden` is true (Naukri's salary filter still matches them by their hidden range).
- Above 15,000 jobs, a split search may still miss some jobs; the run log says so when it happens.
- The company e-mails need the company's website, which Naukri shows on the job page of some companies only (about 1 job in 12 in our sample), and on the company page of large companies (about 1 job in 3 with **Add company details**): a job whose company shows no website goes out without contacts. The option does nothing without **Extract details** or job ids.
- Fields marked detail are null or empty when `extractDetails` is off; the company-page fields stay empty for companies that have no Naukri page (most small employers).
- `onlyNew` remembers job ids, not their content: a job whose salary changed is not returned again.
- Two runs sharing the same `stateKey` at the same time may both return the same new job.

**A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with `onlyNew`, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". Resurrect it to go on from there, or give the next run a longer timeout (Run options).

**A run the platform stops without warning** (out of memory)

- Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the jobs already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them.
- With `onlyNew`, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the jobs it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the jobs of its last 2 seconds once more.

#### Something doesn't work?

The last line of the log counts the jobs saved, filtered out and no longer on Naukri (expired while the run was reading them), and the requests that failed after every retry. Those requests and the expired jobs are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause.

If Naukri changes its pages, you are told instead of paying for blank rows. A results page that counts jobs but gives none the Actor can read is an error (listed in `FAILED_REQUESTS`), never a quiet "No jobs found". If the first 20 jobs read all lack their title, posting date, company name, location, skills, experience, salary text or — with `extractDetails` — description, the run saves nothing more, stops and fails, and its last message names the missing field: at most those first jobs are charged. A job that `postedAfter` / `postedBefore` drops because it has no date at all counts among those 20. An internship found by the results list does not count for the date, skills or experience (Naukri never shows them there), nor any internship for the salary text; a walk-in found by the results list does not count for the experience. A run of fewer jobs (a scheduled `onlyNew` run that finds a few new ones, a small **Max jobs**) is checked at its end, from 5 jobs: its jobs are already saved, and the run fails with the missing field instead of ending green.

### 🛟 Support

Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which URLs failed and why.

# Actor input Schema

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

Naukri search-result URLs (`https://www.naukri.com/python-developer-jobs-in-bangalore?experience=3&jobAge=7`: keyword, location and every filter of the URL are kept, pagination is automatic) or single job URLs (`https://www.naukri.com/job-listings-python-developer-hexaware-technologies-bengaluru-5-to-9-years-160126029546`). When this list is not empty, the search fields below are ignored; filters, caps and monitoring still apply. Max 1 000 URLs. Naukri filters set below are added to the URL's own; when both set the same filter, the URL wins.

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

Naukri job ids (the 12 digits at the end of a job URL, `160126029546`) to extract directly, like pasting their job URLs. When this list is not empty, the search fields are ignored.

## `query` (type: `string`):

Job title, skill, designation or company, as typed in the Naukri search box (`python developer`, `sales`, `walkin`). Empty = every job of the location and filters.

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

Several keywords in one run: one search per keyword (times each location below). Added to **Search keywords**; jobs found by several searches are saved once.

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

City or area as typed on Naukri, no id needed: `Bangalore`, `Delhi NCR`, `Pune`, `Remote`. Empty = all India.

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

Several locations in one run: every keyword is searched in every location (3 keywords × 4 locations = 12 searches, max 500). Added to **Location**.

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

Maximum number of jobs to save for the whole run (after deduplication and filters). 0 = no limit. One Naukri search gives up to 15 000 jobs; bigger searches are split automatically.

## `maxItemsPerQuery` (type: `integer`):

Cap for EACH search (keyword × location, or search URL), so that the first search cannot use up the whole **Max jobs** budget. 0 = no per-search cap.

## `experience` (type: `integer`):

Your experience in years: Naukri keeps the jobs whose experience range includes it (`5` = jobs open to 5 years). Empty = all.

## `freshness` (type: `string`):

Jobs posted in the last N days (Naukri's own filter). For any other date range use **Posted after** / **Posted before** below.

## `workMode` (type: `array`):

Empty = all.

## `salaryRanges` (type: `array`):

Naukri salary bands, in lakhs of rupees per year (1 lakh = ₹100 000). Several = any of them. Most jobs hide their salary: Naukri still matches them by the hidden range.

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

Order of the jobs. With a cap (**Max jobs**), `Date` gives the newest jobs of a search Naukri serves whole (up to 15 000 jobs); a bigger search is read in parts, each one newest first, so the jobs kept are recent ones, not exactly the newest of the whole search. **Posted after** and **Only new jobs** always read by date (newest first), whatever is chosen here.

## `postedBy` (type: `string`):

Jobs posted by the hiring company itself, or by recruitment consultants (agencies).

## `companyTypes` (type: `array`):

Empty = all.

## `departments` (type: `array`):

Naukri department (functional area). Empty = all.

## `industries` (type: `array`):

Industry names as Naukri shows them (`IT Services & Consulting`, `Banking`, `Pharmaceutical & Life Sciences`) or their Naukri ids (`109`). Case ignored. An unknown name stops the run before any job is charged and shows the 3 closest names Naukri knows (or paste the id read in a Naukri URL, `industryTypeIdGid=109`).

## `roleCategories` (type: `array`):

Role category names as Naukri shows them (`Software Development`, `Retail & B2C Sales`, `Accounting & Taxation`) or their Naukri ids (`1028`). Case ignored; an unknown name stops the run before any job is charged.

## `companyGroupIds` (type: `array`):

Only the jobs of these companies: Naukri company-group ids (`10476` = Accenture, `13832` = Infosys) — the `groupId` field of any result. Combine with an empty keyword to get every open job of a company.

## `ugCourses` (type: `array`):

Education asked for (graduation). Empty = all.

## `pgCourses` (type: `array`):

Education asked for (post-graduation). Empty = all.

## `stipends` (type: `array`):

Internships only. Empty = all.

## `internshipDurations` (type: `array`):

Internships only. Empty = all.

## `extractDetails` (type: `boolean`):

Open each job (1 extra request per job): full description (text and HTML), all key skills, education, applicants and views, role, department, industry, employment type, company description, address and website, e-mails and phones written in the ad, and the AmbitionBox block (rating, employee reviews, salary range for the role, benefits, interview questions). Charged per job whose page is read (event `result-with-details`, see the pricing). Unticked (default) = the fields of the results list only (faster, cheaper).

## `includeMarketStats` (type: `boolean`):

Adds one record, `MARKET_STATS`, to the run's key-value store (Output tab): one sheet per search with Naukri's own counts for the WHOLE search (not only the jobs saved): total jobs, jobs by salary band, city, work mode, who posted the job (company or consultant), industry, department, role category, company type, top hiring companies, degrees and internship pay and length. One sheet per search you typed or pasted (not per part of a split search), no extra request. Charged once per sheet (event `market-stats`, see the pricing); a search with no job gives no sheet and no charge; with **Max jobs**, the run stops reading once it is reached: the searches not read by then have no sheet (and no charge); at most 500 sheets per run; unticked (default) = never charged.

## `includeCompanyDetails` (type: `boolean`):

Reads the Naukri page of each hiring company (1 extra request per company, once per run): company type, year founded, size, headquarters, offices, followers, tags, overall rating and reviews, ratings by topic, benefits reported by employees, salaries by role. Only large companies have such a page (most small employers do not): for the others these fields stay empty, except what the job ad itself shows about its company. Charged once per company found per run (event `company-details`, see the pricing), on the first job of that company; its other jobs carry the same fields at no extra cost; a company with no page is never charged; unticked (default) = never charged.

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

Visits each company's own website (home page, contact and legal pages, 3 pages max, once per company per run) to find its e-mail addresses, phone numbers and social links. Needs **Extract details** or job ids (ignored with a warning otherwise: the website is only on the job page). The website is read from the job page, else from the company block of the job, else from the company page (**Add company details**): jobs of a company that publishes none go out without contacts; this is the case for most small employers (about 1 job in 12 shows a website on its job page alone, about 1 in 3 with **Add company details**). Charged as a separate event, once per company where an e-mail is found (event `email-enriched`, see the pricing), on the first job of that company; its other jobs carry the same contacts at no extra cost; the phone numbers and social links found on the same pages come with it, and a company where no e-mail is found costs nothing. Unticked (default) = never charged. The e-mails written in the job description itself (**Extract details**) are a different field (`emails`).

## `postedAfter` (type: `string`):

Only jobs posted on or after this date (Naukri's posting date, `publishedAt`): `2026-09-01`, or a period before now such as `7 days`, `2 weeks`, `1 month` (API: `24 hours` and full ISO date-times work too). Naukri dates no internship on the results list: tick **Extract details** to filter internships by date.

## `postedBefore` (type: `string`):

Only jobs posted on or before this date (the whole day is included), or older than a period such as `30 days`.

## `excludeKeywords` (type: `array`):

Drop the jobs whose title contains one of these texts (case and accents ignored). A text inside a longer word counts too: `intern` also drops "International Sales".

## `includeKeywords` (type: `array`):

Keep only the jobs whose title, key skills or short description contain at least one of these words (case and accents ignored). With **Extract details**, the full key-skills list of the job page is read (the results list shows about 8). Empty = all.

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

Drop the jobs whose company name (or the client named by a consultant) contains one of these words (`Infosys`, `staffing`). Case and accents ignored.

## `experienceMin` (type: `integer`):

Keep only the jobs whose experience range reaches this number of years (`5` keeps `3-7 Yrs` and `5-10 Yrs`, drops `0-2 Yrs`). Jobs without an experience range are kept. A minimum above the maximum is refused.

## `experienceMax` (type: `integer`):

Keep only the jobs whose experience range starts at or below this number of years (`2` keeps `0-1 Yrs` and `2-5 Yrs`, drops `3-7 Yrs`; `0` = fresher jobs). Jobs without an experience range are kept.

## `walkInOnly` (type: `boolean`):

Keep only the walk-in interview jobs (with their dates, venue and contact). Tip: the keyword `walkin` finds most of them.

## `excludeWalkIns` (type: `boolean`):

Drop the walk-in interview jobs.

## `walkInWithinDays` (type: `integer`):

Walk-in jobs only: keep the drives still open today or starting within this many days (`0` = today, `7` = this week). Implies **Walk-in drives only**; cannot be combined with **Exclude walk-in drives**.

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

Keep only the jobs that show their salary (most Naukri jobs hide it).

## `minSalaryLakhs` (type: `number`):

Keep only the jobs whose shown maximum salary reaches this amount, in lakhs per year (`8.5` = ₹8.5 L). Jobs with a hidden salary are dropped. A minimum above the maximum is refused.

## `maxSalaryLakhs` (type: `number`):

Keep only the jobs whose shown minimum salary is at or below this amount, in lakhs per year. Jobs with a hidden salary are dropped.

## `minCompanyRating` (type: `number`):

Keep only the jobs of companies rated at least this on AmbitionBox (out of 5, `3.5`). Companies without a rating are dropped.

## `requirePhone` (type: `boolean`):

Keep only the jobs with at least one phone number: walk-in contact phone (in the results list), or a number written in the job description (needs **Extract details**).

## `requireEmail` (type: `boolean`):

Keep only the jobs with at least one e-mail address written in the job description (needs **Extract details**: the run is refused without it).

## `naukriApplyOnly` (type: `boolean`):

Drop the jobs that send the candidate to the employer's own site to apply (those have an `applyUrl`).

## `onlyNew` (type: `boolean`):

Skip the jobs that a previous run (same **Memory key**) already delivered: they are not saved and not charged and, for jobs found by a search, their page is not even opened. First run = everything is new.

## `stateKey` (type: `string`):

Name of the memory used by **Only new jobs**. Give each schedule / task its own key (e.g. `python-bangalore`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every job again. Untick it afterwards.

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

Apify Proxy or your own proxies. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor.

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

Maximum number of requests processed in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Most requests to the site in any 60 seconds, all of them counted: results pages and the extra page read for a job. A budget, not an even pace: up to this many can leave at once when the minute starts (spread them with the minimum delay below). Lower it if the site answers HTTP 429 / 403 in the log.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two requests, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly instead of letting them go out in a burst. 0 = no gap.

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

Retries per request before it is marked as failed. Behind a proxy, a request the site turns away is also retried on a new proxy session up to 10 times without using up these retries.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "startUrls": [],
  "jobIds": [],
  "query": "python developer",
  "searchQueries": [],
  "location": "Bangalore",
  "locations": [],
  "maxItems": 100,
  "maxItemsPerQuery": 0,
  "freshness": "",
  "workMode": [],
  "salaryRanges": [],
  "sortBy": "relevance",
  "postedBy": "any",
  "companyTypes": [],
  "departments": [],
  "industries": [],
  "roleCategories": [],
  "companyGroupIds": [],
  "ugCourses": [],
  "pgCourses": [],
  "stipends": [],
  "internshipDurations": [],
  "extractDetails": false,
  "includeMarketStats": false,
  "includeCompanyDetails": false,
  "enrichEmails": false,
  "excludeKeywords": [],
  "includeKeywords": [],
  "excludeCompanies": [],
  "walkInOnly": false,
  "excludeWalkIns": false,
  "onlyWithSalary": false,
  "requirePhone": false,
  "requireEmail": false,
  "naukriApplyOnly": false,
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8,
  "maxRequestsPerMinute": 120,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `marketStats` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "python developer",
    "location": "Bangalore",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/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 = {
    "query": "python developer",
    "location": "Bangalore",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/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 '{
  "query": "python developer",
  "location": "Bangalore",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/naukri-jobs-scraper --silent --output-dataset

```

## MCP server setup

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