# Justdial Scraper — India Business Directory Leads (`haketa/justdial-scraper`) Actor

Scrape Justdial.com, India's #1 local business directory. Get businesses by category and city: name, phone, address, area, pincode, GPS, rating, review count, verified status and category. Great for lead generation. No login or API key. Export JSON, CSV, Excel.

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

## Pricing

from $2.00 / 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/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

## Justdial Scraper 🇮🇳 — India Business Directory Leads (Phone, WhatsApp, Address, GPS & Ratings)

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00C853?style=flat-square\&logo=apify)](https://apify.com/haketa/justdial-scraper)
[![India B2B Leads](https://img.shields.io/badge/🇮🇳-India_%231_Business_Directory-FF9933?style=flat-square)]()
[![Direct Phones](https://img.shields.io/badge/📞-100%25_Direct_Phone_Coverage-2da44e?style=flat-square)]()
[![GPS & Pincode](https://img.shields.io/badge/📍-Address_·_Pincode_·_GPS-1f6feb?style=flat-square)]()
[![1,000+ Deep Pagination](https://img.shields.io/badge/🔁-1,000%2B_Leads_Multi--City_Scale-6f42c1?style=flat-square)]()
[![Export](https://img.shields.io/badge/⬇️-JSON_·_CSV_·_Excel_·_API-24292f?style=flat-square)]()

**Extract local businesses from [Justdial.com](https://www.justdial.com) — India's largest local business directory — at scale, with no login, no cookies, and no coding.** This **Justdial scraper** lets you search any business category across any Indian city (or paste Justdial search URLs directly) and exports clean, structured B2B lead records: **business name, direct contact phone number, WhatsApp number, full street address, locality/area, city, pincode, exact GPS coordinates (`lat` / `lng`), star rating, total review count, Justdial verified status, paid-listing status, website, and category.**

Bulk export your **Justdial business leads** to **JSON, CSV, Excel (XLSX), or via the Apify API**.

> 🎯 **Built for** B2B sales & outbound prospecting teams, telemarketing and call centers, Indian market researchers, digital marketing agencies, CRM data-enrichment pipelines, real-estate & retail expansion analysts, and developers who need a dependable **Justdial data extractor**.

***

### ⚡ At a glance

| Feature | Details |
| :--- | :--- |
| 🎯 **Target directory** | [Justdial.com](https://www.justdial.com) — all Indian cities, towns, and business categories |
| 🔍 **Input modes** | **Search Terms + City** (`searchTerms` + `city`) or direct **Justdial Search URLs** (`startUrls`) |
| 📞 **Lead & contact fields** | `name`, `phone` (direct number), `whatsapp`, `website`, `address`, `area`, `city`, `pincode`, `lat`, `lng` |
| ⭐ **Reputation & trust** | `rating` (out of 5), `totalReviews`, `verified` badge, `isPaid` (promoted flag), `openNow`, `category`, `thumbnail` |
| 🔁 **Pagination & 1,000+ scale** | Automatic page walking (`maxPagesPerSearch: 0`) + automatic multi-city & multi-category expansion when `maxItems: 1000+` is requested |
| 🧹 **Deduplication** | 100% deduplicated across pages, categories, and cities by Justdial's unique `docid` |
| 🌐 **Proxy configuration** | Prefilled **Indian Residential Proxy** (`RESIDENTIAL`, country `IN`) — works out of the box |
| ⬇️ **Export formats** | **JSON, CSV, Excel, HTML, XML, RSS**, plus direct integration with **Make, Zapier, n8n, Google Sheets & API** |

***

### 🔎 Why scrape Justdial for Indian B2B leads?

Justdial is the backbone of local commerce discovery in India, indexing tens of millions of SMBs, clinics, restaurants, manufacturers, wholesalers, contractors, salons, CA firms, and service providers across every Tier-1, Tier-2, and Tier-3 city. Every listing carries the exact data points a sales, marketing, or market-intelligence team needs: a **reachable phone number**, a **complete street address with pincode**, **precise latitude/longitude**, **category tags**, and **customer ratings & review counts**.

Collecting Justdial data manually is slow and frustrating: search pages show only 10 results at a time, duplicate promoted listings reappear across pages, and ordinary requests from outside India receive empty pages. Copy-pasting hundreds of businesses into Excel takes hours and cannot be automated.

This **Justdial data extractor** turns Justdial into a clean, on-demand lead database:

- 🎯 **B2B lead generation & outbound sales** — build targeted call and WhatsApp lists by category and city in minutes.
- 📞 **Telemarketing & inside sales pipelines** — feed verified business phone numbers (`phone`) and ratings directly into your dialer or CRM.
- 🗺️ **Geospatial & retail territory mapping** — plot every competitor, supplier, or franchise prospect using exact `lat`, `lng`, `area`, and `pincode` fields.
- 🏢 **CRM hygiene & B2B data enrichment** — append verified addresses, pincodes, ratings, and review volumes to existing Indian company lists.
- ⭐ **Reputation & local SEO benchmarking** — identify high-volume businesses with low ratings or unverified profiles that need digital marketing or reputation management services.
- 📊 **Market sizing & competitive intelligence** — measure business density and review distribution across Mumbai, Delhi, Bangalore, Hyderabad, Chennai, Pune, Ahmedabad, Kolkata, and beyond.

***

### ✨ What this Justdial scraper does

- ✅ **Search any category in any Indian city** — enter one or multiple keywords in `searchTerms` (e.g., `["Restaurants", "Cafes", "Cloud Kitchens"]`) and a target `city` (e.g., `"Mumbai"`), or paste ready-made URLs into `startUrls`.
- ✅ **100% direct phone number extraction** — captures the business contact number (`phone`) directly from Justdial's structured listing payload, plus `whatsapp` and `website` whenever listed.
- ✅ **Complete location & geospatial data** — extracts `address`, `area` (neighborhood/locality), `city`, `pincode`, and numeric `lat` / `lng` coordinates on virtually every record.
- ✅ **Automatic deep pagination (`maxPagesPerSearch: 0`)** — walks result pages automatically until the search is exhausted or your `maxItems` target is met, stopping early if consecutive pages yield no new unique businesses.
- ✅ **Unlocked 1,000+ business scaling** — because a single Justdial `(city, category)` search typically contains ~50–60 unique businesses after deduplication, requesting a large `maxItems` (e.g., `500` or `1,000+`) automatically expands across major Indian cities and related categories so your run reaches 1,000+ unique leads seamlessly.
- ✅ **Global deduplication by `docid`** — Justdial frequently repeats sponsored businesses across pages; our scraper filters every record through a run-wide `docid` set so you never pay for or export duplicate rows.

***

### 🎯 Use cases & B2B workflows

| Industry / Team | How They Use Justdial Data |
| :--- | :--- |
| 📞 **B2B Sales & Outbound Agencies** | Scrape `Interior Designers`, `Architects`, and `Modular Kitchen Dealers` in Bangalore, filter to `verified: true` and `totalReviews > 20`, and export to CSV for immediate cold-calling. |
| 💻 **SaaS & POS Vendors** | Extract `Restaurants`, `Salons`, `Gyms`, and `Retail Shops` across Tier-1 and Tier-2 Indian cities to build territory-assigned prospect lists for field sales reps. |
| 📈 **Digital Marketing & Local SEO Agencies** | Find established local businesses (`totalReviews > 100`) that lack a `website` (`website: null`) or aren't running promoted placements (`isPaid: false`)—the highest-converting prospects for web design and ad services. |
| 🏥 **Healthcare & Pharma Distributors** | Map `Pharmacies`, `Diagnostic Centres`, `Dental Clinics`, and `Hospitals` by `pincode` and GPS coordinates (`lat`, `lng`) to optimize medical representative routing. |
| 🏗️ **FMCG, Wholesale & Supply Chain Teams** | Build pan-India distributor and dealer directories (`Hardware Shops`, `Electrical Dealers`, `Packaging Manufacturers`) across 20+ metropolitan areas in a single run. |

***

### 📥 Input configuration

Enter one or more **Search Terms / Categories** and a **City**, or paste **Start URLs**. All fields are optional and prefilled with sensible defaults so you can test the Actor with a single click.

| Field | Type | Default / Prefill | Description |
| :--- | :--- | :--- | :--- |
| `searchTerms` | `array<string>` | Prefill `["Restaurants"]` | Categories or keywords to search for (e.g., `"Dentists"`, `"Gyms"`, `"Real Estate Agents"`, `"Plumbers"`). |
| `city` | `string` | `"Mumbai"` | Indian city to search in (e.g., `"Mumbai"`, `"Delhi"`, `"Bangalore"`, `"Hyderabad"`, `"Chennai"`, `"Pune"`). |
| `startUrls` | `array<string>` | `[]` | Optional. Full Justdial search URLs (e.g., `https://www.justdial.com/Mumbai/Restaurants`). Overrides `searchTerms` and `city` when provided. |
| `maxItems` | `integer` | Default `0` (Prefill `50`) | Maximum unique businesses to collect across the run. `0` = unlimited. Prefilled to `50` so test runs finish in ~25 seconds. |
| `maxPagesPerSearch` | `integer` | `0` | Maximum result pages to read per search term/URL (`0` = auto/unlimited governed by `maxItems`). Each page holds ~10 listings. |
| `proxyConfiguration` | `object` | Indian Residential (`IN`) | **Required by Justdial.** Prefilled with Apify Residential Proxy pinned to India (`IN`). Keep the default setting enabled. |

#### Example input — fast category search in one city

```json
{
  "searchTerms": ["Restaurants"],
  "city": "Mumbai",
  "maxItems": 50,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IN"
  }
}
```

#### Example input — 1,000+ multi-category B2B lead generation run

```json
{
  "searchTerms": [
    "Interior Designers",
    "Architects",
    "Modular Kitchen Dealers",
    "Civil Contractors",
    "Home Automation Dealers"
  ],
  "city": "Bangalore",
  "maxItems": 1000,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IN"
  }
}
```

***

### 📤 Output schema & field reference

Each business is saved as a normalized JSON record. Below is an actual record captured from a live Mumbai run:

```json
{
  "docid": "022PXX22.XX22.140804130028.J6U9",
  "name": "Mao Family Restaurant",
  "phone": "09845262099",
  "whatsapp": null,
  "address": "Near Theatre Kalbadevi",
  "area": "Lohar Chawl Kalbadevi",
  "city": "Mumbai",
  "pincode": "400002",
  "lat": 18.944402,
  "lng": 72.829283,
  "rating": 4.2,
  "totalReviews": 10055,
  "verified": true,
  "isPaid": true,
  "category": "Restaurants, North Indian Restaurants",
  "openNow": true,
  "website": null,
  "thumbnail": "https://images.jdmagicbox.com/comp/mumbai/u9/022pxx22.xx22.140804130028.j6u9/catalogue/mao-family-restaurant-kalbadevi-mumbai-restaurants-1.jpg",
  "url": "https://www.justdial.com/Mumbai/Mao-Family-Restaurant-Near-Theatre-Kalbadevi-Lohar-Chawl-Kalbadevi/022PXX22-XX22-140804130028-J6U9_BZDET",
  "searchTerm": "Restaurants",
  "scrapedAt": "2026-11-09T18:20:00.000Z"
}
```

#### 🏢 Identity & Contact Fields

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `docid` | `string` | 🟢 High (100%) | Unique Justdial business identifier used for run-wide deduplication. |
| `name` | `string` | 🟢 High (100%) | Official business or establishment name. |
| `phone` | `string` | 🟢 High (~98–100%) | Direct contact phone / virtual number displayed on the listing. |
| `whatsapp` | `string \| null` | 🟡 Conditional | WhatsApp contact number when exposed by the business. |
| `website` | `string \| null` | 🟡 Conditional | External business website URL when listed on Justdial. |
| `url` | `string` | 🟢 High (100%) | Direct link to the business listing on Justdial.com. |

#### 📍 Location & Geospatial Fields

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `address` | `string` | 🟢 High (100%) | Street address and landmark details. |
| `area` | `string` | 🟢 High (100%) | Neighborhood or locality within the city (e.g., `Andheri West`, `Kalbadevi`). |
| `city` | `string` | 🟢 High (100%) | City name (e.g., `Mumbai`, `Delhi`, `Bangalore`). |
| `pincode` | `string` | 🟢 High (~99%) | 6-digit Indian postal PIN code. |
| `lat` | `number` | 🟢 High (~99%) | GPS latitude coordinate (WGS84). |
| `lng` | `number` | 🟢 High (~99%) | GPS longitude coordinate (WGS84). |

#### ⭐ Reputation, Category & Metadata Fields

| Field | Type | Coverage | Description |
| :--- | :--- | :--- | :--- |
| `rating` | `number \| null` | 🟢 High (~95%) | Average customer star rating (0.0 to 5.0). |
| `totalReviews` | `integer \| null` | 🟢 High (~95%) | Total number of customer ratings and reviews on Justdial. |
| `verified` | `boolean` | 🟢 High (100%) | `true` when the business carries Justdial's Verified trust stamp. |
| `isPaid` | `boolean` | 🟢 High (100%) | `true` when the business is a paid/sponsored Justdial advertiser. |
| `category` | `string` | 🟢 High (100%) | Comma-separated business categories assigned by Justdial. |
| `openNow` | `boolean` | 🟢 High (100%) | `true` if the business is marked open at the time of extraction. |
| `thumbnail` | `string \| null` | 🟢 High (~90%) | Primary photo/catalogue image URL for the business. |
| `searchTerm` | `string` | 🟢 High (100%) | The search keyword or category that discovered this listing. |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO 8601 UTC timestamp of when the record was scraped. |

***

### 🔁 Pagination & scaling to 1,000+ businesses

Justdial returns roughly **10 listings per page**, and a single `(city, category)` search typically exposes up to 10 pages (~100 raw rows, which deduplicate to **~50–55 unique businesses** after removing repeated promoted cards).

To make both small previews and large 1,000+ lead builds effortless:

1. **Auto page walking (`maxPagesPerSearch: 0`):** By default, `maxPagesPerSearch` is `0` (auto), meaning the scraper walks every available page for each search term and moves on automatically as soon as Justdial stops returning new unique businesses.
2. **Automatic multi-city & multi-category expansion for 1,000+ runs:** When you set `maxItems` above 50 (e.g. `maxItems: 1000`) without locking `startUrls`, the scraper first exhausts your specified `(city, searchTerms)` combinations, then automatically expands your search terms across India's top 20 metropolitan cities (`Mumbai`, `Delhi`, `Bangalore`, `Hyderabad`, `Ahmedabad`, `Chennai`, `Kolkata`, `Pune`, `Jaipur`, `Surat`, `Lucknow`, etc.) and top commercial categories until your exact `maxItems` target is reached.

***

### ⚙️ How to use & automate

1. **Open the Justdial Scraper** in Apify Console.
2. **Enter your target categories** in `searchTerms` (e.g. `["Dentists", "Orthodontists"]`) and set your target `city` (e.g. `"Delhi"`).
3. **Set your limit:** Keep `maxItems: 50` for a quick 25-second preview, or raise it to `500` or `1,000+` for bulk lead generation.
4. **Leave Proxy on Indian Residential (`IN`)** and click **Start**.
5. **Export your leads:** Download as **Excel, CSV, or JSON**, or connect directly to **Google Sheets, HubSpot, Salesforce, Make, Zapier, or n8n** via the Apify API.

#### API example (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("haketa/justdial-scraper").call(run_input={
    "searchTerms": ["Real Estate Agents", "Builders", "Property Consultants"],
    "city": "Mumbai",
    "maxItems": 200,
    "maxPagesPerSearch": 0,
})

for lead in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{lead['name']} | {lead['phone']} | {lead['area']} ({lead['pincode']}) | ⭐ {lead['rating']}")
```

#### API example (Node.js)

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('haketa/justdial-scraper').call({
    searchTerms: ['Gyms', 'Fitness Centres', 'Yoga Classes'],
    city: 'Bangalore',
    maxItems: 150,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Collected ${items.length} unique Bangalore fitness leads.`);
```

***

### 💡 Best practices & tips

- 🇮🇳 **Never disable the Indian Residential proxy:** Justdial blocks datacenter IPs and non-Indian traffic with a 14-byte empty response. The prefilled `RESIDENTIAL` + `IN` proxy uses compact JSON endpoints (~0.5 MB per 50 leads), keeping residential proxy transfer costs ultra-low.
- 🎯 **Use specific sub-categories for targeted single-city lists:** Because Justdial caps any single search query at ~55 unique businesses, entering 10 specific sub-categories (e.g., `"Dental Clinics"`, `"Orthodontists"`, `"Pediatric Dentists"`, `"Dental Implant Centres"`) in one city yields hundreds of businesses from that exact city.
- 📞 **Filter by `isPaid` and `verified`:** Businesses with `isPaid: true` are actively spending money on local advertising—making them prime B2B prospects for marketing, SaaS, and financial services.

***

### ⚠️ Honest limitations

- **Single-search cap on Justdial:** Justdial's backend serves at most ~100 raw rows (~50–55 unique businesses) for any single `(city, keyword)` query. To collect 500–1,000+ businesses within a *single* city, pass multiple related keywords in `searchTerms`; otherwise, the scraper automatically expands across additional Indian cities to fulfill your `maxItems` target.
- **Indian Residential proxy required:** Runs using datacenter proxies or non-IN countries will not receive listing data from Justdial.

***

### ❓ Frequently asked questions (FAQ)

**Do I need a Justdial login, cookies, or API key?**
No. The Actor extracts public directory listings without any account or authentication.

**Are phone numbers real and unmasked?**
Yes. Every listing returns the contact `phone` number provided by Justdial's data payload, achieving ~98–100% phone coverage across runs.

**How fast is the scraper and how much proxy data does it use?**
Instead of loading heavy images and full browser pages, this scraper queries Justdial's compact structured data endpoint over HTTP. A 50-business run finishes in ~20–35 seconds and consumes less than 1 MB of residential proxy traffic.

**How do I scrape 1,000+ businesses in a single run?**
Set `maxItems: 1000` (and leave `maxPagesPerSearch: 0`). You can either supply 15–20 category keywords in `searchTerms`, or let the scraper automatically expand your search across top Indian cities and categories until 1,000 unique businesses are saved.

**How does deduplication work?**
Every Justdial business has a permanent `docid` (e.g., `022PXX22.XX22.140804130028.J6U9`). The Actor maintains a run-wide set of seen `docid` values so promoted listings that repeat on every page or across overlapping categories are saved only once.

**Can I scrape specific Justdial URLs from my browser?**
Yes. Copy any search URL from Justdial (such as `https://www.justdial.com/Pune/Software-Companies`) and paste it into `startUrls`.

***

### 🔌 CRM integrations & lead-pipeline automation

Turn your **Justdial business data** into an automated Indian B2B sales machine by connecting the Apify Dataset to your outbound stack:

- 📊 **Google Sheets & Excel Online:** Sync fresh Indian business leads directly into shared territory spreadsheets for regional SDRs and telemarketing teams.
- 🏢 **HubSpot, Salesforce, Zoho CRM & Pipedrive:** Use **Make, Zapier, or n8n** to trigger on run completion, deduplicate against your existing CRM by `docid` or `phone`, and create enriched Company records with `address`, `pincode`, `rating`, and `totalReviews`.
- 💬 **WhatsApp Business & Cloud Dialers (Exotel, Knowlarity, Ozonetel):** Route `phone` and `whatsapp` fields straight into Indian cloud telephony dialers for automated IVR or outbound sales queues.
- 🗺️ **QGIS, Tableau & Power BI:** Import `lat`, `lng`, `pincode`, and `area` to build heatmaps of competitor density, verified vs. unverified merchants, and customer review volume across Indian metropolitan areas.

***

### 📊 Lead scoring & segmentation recipe (Python / Pandas)

After exporting your Justdial dataset, you can segment high-intent prospects (for example, established businesses with strong review volume that still lack a website) in seconds:

```python
import pandas as pd

## Load exported Justdial leads from JSON or CSV
df = pd.read_json("justdial_leads.json")

## 1. High-value digital agency prospects:
##    Verified or active businesses (50+ reviews) that have NO website listed
no_website_leads = df[
    (df["phone"].notna())
    & (df["totalReviews"].fillna(0) >= 50)
    & (df["website"].isna())
].sort_values("totalReviews", ascending=False)

print(f"Found {len(no_website_leads)} high-review businesses without a website:")
print(no_website_leads[["name", "phone", "area", "city", "rating", "totalReviews"]].head(15))

## 2. Active advertisers (isPaid == True) by locality / pincode
paid_by_area = (
    df[df["isPaid"] == True]
    .groupby(["city", "area", "pincode"])
    .size()
    .reset_index(name="paid_businesses")
    .sort_values("paid_businesses", ascending=False)
)
print(paid_by_area.head(10))
```

#### Equivalent SQL query for CRM ingestion

```sql
SELECT
    docid,
    name,
    phone,
    whatsapp,
    category,
    area,
    city,
    pincode,
    rating,
    totalReviews,
    verified,
    isPaid
FROM justdial_businesses
WHERE phone IS NOT NULL
  AND verified = TRUE
ORDER BY totalReviews DESC, rating DESC;
```

***

### 🔗 Related B2B & local directory scrapers

- [Google Maps Scraper — Business Leads, Phones & Websites](https://apify.com/haketa/google-maps-scraper)
- [2GIS Scraper — Local Business Data (Russia, CIS, Central Asia)](https://apify.com/haketa/2gis-scraper)
- [Kakao Map Scraper — Korea Local Businesses & Reviews](https://apify.com/haketa/kakao-map-scraper)
- [Hitta.se Scraper — Swedish Business Leads, Emails & Org Numbers](https://apify.com/haketa/hitta-se-business-scraper)
- [Bing Maps Business Leads Scraper — Email, Phone & Socials](https://apify.com/haketa/bing-maps-contacts-scraper)

***

### 📋 Changelog

- **v1.2 (2026-11)** — Unlocked **1,000+ multi-city & multi-category pagination**: changed `maxPagesPerSearch` default to `0` (auto/unlimited governed by `maxItems`), added automatic consecutive-duplicate page detection, added automatic multi-city/category expansion for `maxItems > 50`, and tuned prefill to `50` items for fast `<30s` test runs.
- **v1.1 (2026-10)** — Improved session rotation and columnar field normalization (`whatsapp`, `isPaid`, `openNow`, `pincode`, `lat`/`lng`).
- **v1.0 (2026-09)** — Initial release with Indian residential HTTP extraction and `docid` deduplication.

***

▶️ **Ready to build your Indian B2B lead list?** Enter your categories and city, click **Start**, and export verified Justdial business leads to Excel, CSV, or JSON!

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/justdial-scraper/changelog.md

# Actor input Schema

## `searchTerms` (type: `array`):

What to search for in the chosen city, e.g. 'Restaurants', 'Gyms', 'Dentists', 'Plumbers'. Each term is searched separately. Leave empty if you use Start URLs.

## `city` (type: `string`):

Indian city to search in, e.g. 'Mumbai', 'Delhi', 'Bangalore', 'Chennai'. Applied to every Search Term.

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

Optional. Paste full Justdial search URLs (e.g. https://www.justdial.com/Mumbai/Restaurants) to scrape them directly. When provided, Search Terms and City are ignored for these URLs.

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

Maximum number of businesses to collect across all searches. 0 = unlimited.

## `maxPagesPerSearch` (type: `integer`):

How many result pages to scrape per search term / URL (0 = auto/unlimited governed by Max Items). Each page has about 10 businesses.

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

Justdial requires an Indian Residential proxy — it blocks other IPs. The default works out of the box.

## Actor input object example

```json
{
  "searchTerms": [
    "Restaurants"
  ],
  "city": "Mumbai",
  "startUrls": [],
  "maxItems": 50,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open to view and export all scraped listings (JSON, CSV, Excel).

# 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 = {
    "searchTerms": [
        "Restaurants"
    ],
    "city": "Mumbai",
    "startUrls": [],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/justdial-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 = {
    "searchTerms": ["Restaurants"],
    "city": "Mumbai",
    "startUrls": [],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/justdial-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 '{
  "searchTerms": [
    "Restaurants"
  ],
  "city": "Mumbai",
  "startUrls": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call haketa/justdial-scraper --silent --output-dataset

```

## MCP server setup

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