# Justdial Scraper — Indian Business Leads, Phones & E-mails (`logiover/justdial-scraper`) Actor

Justdial scraper: export Indian businesses from justdial.com by category and city — phone (Justdial virtual numbers flagged), WhatsApp, e-mail, website, address, pincode, GPS, rating, ratings count, categories, hours, year established. 10k+ per big city. No login. Not affiliated with Justdial.

- **URL**: https://apify.com/logiover/justdial-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 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 — Indian Business Leads with Phones, WhatsApp & E-mail

> **Not affiliated with Justdial.** This is an independent tool that reads the business listings Justdial (justdial.com) shows to every visitor. "Justdial" and "JD" are trademarks of Just Dial Limited and are used here only to describe what the tool reads.

**Justdial Scraper** exports local businesses from **justdial.com** — the local search directory millions of Indians use to find a business — into clean rows you can open in Excel, Google Sheets or your CRM. Type a category and a city ("Restaurants" in "Mumbai", "Dentists" in "Pune", "Chartered Accountants" in "Delhi") and get every business Justdial lists for it: **business name, phone number as Justdial shows it (with Justdial virtual numbers flagged), WhatsApp number, e-mail address, website, full postal address with pincode and state, GPS coordinates, rating and number of ratings, main category and every category the business is listed in, opening hours for each day, year of establishment, services and amenities, JD Verified / JD Trust / claimed badges, photos and the Justdial page link**. It works as a **Justdial API alternative**: there is no official Justdial data API for listings, so this Actor reads the same JSON calls Justdial's own mobile site makes, with no login, no browser and no Justdial account. **Scrape justdial.com** and **export Justdial data to CSV, Excel, JSON, XML or HTML**, or pull it straight into your code through the Apify API.

Use it as a **Justdial lead extractor**, **Justdial data extractor**, **Justdial business list downloader** or **Justdial phone number scraper** for any Indian city — Mumbai, Delhi NCR, Bangalore (Bengaluru), Hyderabad, Chennai, Kolkata, Pune, Ahmedabad, Jaipur, Surat, Lucknow, Chandigarh, Indore, Nagpur, Kochi and hundreds more. Justdial shows about 100 businesses per search; this Actor goes much further by also searching every locality the results reveal (Andheri West, Malad West, Koramangala, Vikaspuri…) and removing duplicates by Justdial's own business id — one city × one category measured **10,500 unique restaurants in Mumbai in under six minutes**. If you were looking for "Justdial se data kaise nikale", "Justdial leads download in Excel", "Justdial scraper Python", "Justdial contact number extractor", "जस्टडायल से बिज़नेस लिस्ट और फ़ोन नंबर" or "जस्टडायल डेटा एक्सपोर्ट" — this is the tool: local business leads, B2B prospect lists, market maps by pincode and category, and Justdial listing monitoring, all without copying a single row by hand.

### Table of contents

- [At a glance](#at-a-glance)
- [What you get](#what-you-get)
- [How it works](#how-it-works)
- [Who uses it — 13 workflows](#who-uses-it--13-workflows)
- [Cookbook — 14 ready-to-run inputs](#cookbook--14-ready-to-run-inputs)
- [Quick start in Apify Console](#quick-start-in-apify-console)
- [Quick start with the API](#quick-start-with-the-api)
- [Input reference](#input-reference)
- [Data dictionary](#data-dictionary)
- [Output sample](#output-sample)
- [CSV and Excel columns](#csv-and-excel-columns)
- [Scale and speed](#scale-and-speed)
- [Data quality checks](#data-quality-checks)
- [Pricing](#pricing)
- [Integrations](#integrations)
- [Performance tips](#performance-tips)
- [Troubleshooting](#troubleshooting)
- [Honest limits](#honest-limits)
- [Compared with other ways to get Justdial data](#compared-with-other-ways-to-get-justdial-data)
- [FAQ](#faq)
- [Glossary](#glossary)
- [Is it legal to scrape Justdial?](#is-it-legal-to-scrape-justdial)
- [Changelog](#changelog)
- [Support](#support)

### At a glance

| | |
|---|---|
| **Source** | justdial.com — the listings, business cards and categories Justdial shows to any visitor |
| **Searches** | Category or keyword × city, optional localities, or pasted Justdial search / business URLs |
| **Depth** | ≈100 businesses per Justdial list; locality expansion goes past that (measured: 10,500 unique restaurants in Mumbai, 0 duplicates) |
| **Contact data** | Phone (Justdial call button or WhatsApp), WhatsApp, e-mail(s), website(s) |
| **Location data** | Full address, address line, street, locality, city, state, pincode, latitude/longitude |
| **Business data** | Rating, ratings count, categories, hours per day, year of establishment, services, summary, badges, photos; restaurants: price for two, order-online links |
| **Speed (measured 2026-10-24)** | 20 businesses in 18.8 s (first row after 1.9 s); 1,000 businesses with full business cards in 62.0 s |
| **Login / account** | Not needed |
| **Proxy** | Apify Residential, chosen and rotated automatically (Justdial refuses datacenter IPs) |
| **Export** | JSON, CSV, Excel, XML, HTML, RSS, or via API, webhooks and integrations |
| **Price** | Pay per result: from $3.00 per 1,000 businesses, $2.00 per 1,000 on higher Apify plans |

### What you get

Every row is one business, identified by Justdial's own **docid** (for example `022P8010682` or `011PXX11.XX11.220929130702.E2V8`). The same business found in two localities or two keyword searches is saved — and charged — once.

**Identity and links**

- `docid` — Justdial's permanent business id (the key to deduplicate across runs).
- `name` — business name as listed.
- `url` — the business page on Justdial (`…_BZDET`), `shortUrl` — Justdial's short share link (`https://www.justdial.com/DT-…`).

**Contact (the lead part)**

- `phone` — the best number to call: the number on Justdial's **Call** button if Justdial shows one, otherwise the business's **WhatsApp** number from its card. `phoneType` says which: `justdial_virtual_number` (Justdial's own forwarding number for the business), `direct` (the business's own number on the call button) or `whatsapp`.
- `phones` / `phonesInternational` — every number in national form (`09845248771`) and in international form (`+919845248771`).
- `callButtonNumbers` — only the numbers Justdial's call button shows.
- `whatsapp` — WhatsApp number in international form (`+919892203511`).
- `email` / `emails` — e-mail address(es) on the business card.
- `website` / `websites` — the business's own website(s).

**Location**

- `address` — full postal address as on the business card (`2/344, BMC Colony, Malvani Gate No 2, Off Marve Road, Abdul Hamid Road, Malad West, Mumbai-400095, Maharashtra`).
- `addressLine` and `street` — the two address lines Justdial prints on the result card.
- `area` (locality), `city`, `state`, `pincode`, `latitude`, `longitude`.

**Reputation and badges**

- `rating` (0–5), `reviewCount` (exact number of ratings), `tags` (Justdial labels such as *Top rated*, *Trending*, *Popular*, *Most searched*), `highlights` (short notes such as *High call pick up rate*, offers), `jdVerified`, `jdTrust`, `claimed`.

**Business profile**

- `primaryCategory` / `primaryCategoryId`, `categories` (for restaurants: cuisines), `alsoListedIn` (every Justdial category the business appears in).
- `openStatus` (as shown at the moment of scraping, e.g. *Opens at 11:00 AM*), `businessHours` (each day of the week), `yearEstablished`, `businessSummary`, `services` (amenities and services the business lists — *Home Delivery*, *Parking Available*, *Root Canal*, *Personal Trainers*…).
- Restaurants: `priceForTwo` (₹) and `orderOnlineLinks` (the ordering links Justdial shows).
- `photosCount`, `thumbnail`, `photos` (up to five photo URLs from the result card).

**Search context**

- `searchKeyword`, `searchCity`, `searchArea` (the locality list the business was read from), `position` (its place in that list), `detailsScraped`, `scrapedAt`.

### How it works

1. **Search.** For every keyword × city the Actor asks Justdial for its result list — the same call Justdial's mobile site makes when you scroll. Justdial resolves your word to its own category by itself ("Plumbers" → category 10378025), answers with the first ten businesses and the ids of the whole list (about 100).
2. **Read the whole list.** Further pages are fetched by naming the next ten ids, exactly like the site's infinite scroll. Businesses already collected are skipped before asking, so overlapping lists cost nothing extra.
3. **Expand into localities.** Every locality the results reveal is searched as well — each locality has its own list of about 100 — until your maximum is reached or the city runs out of new localities. One Mumbai run found 1,566 localities.
4. **Open the business card** (on by default): one call per business adds the card fields — WhatsApp, e-mail, website, full address, hours and more.
5. **Save.** Rows are written as soon as they are complete, so the first ones appear within seconds. If the platform moves a run to another server mid-way, the run resumes and skips the businesses it had already saved.

Justdial's firewall refuses datacenter and direct traffic; the Actor handles residential proxies, cookies and refused exits by itself — nothing to configure.

### Who uses it — 13 workflows

**1. Local lead-generation agency.** You sell leads to plumbers' suppliers, electrical wholesalers or insurance agents. Run "Plumbers", "Electricians" and "Carpenters" across ten cities, keep the rows that have `whatsapp` or `email`, and hand each client a fresh list per city every month. `docid` lets you send only businesses they have not seen before.

**2. B2B SaaS sales team (restaurants, salons, clinics).** A POS, booking or billing product needs owners' contact details. Pull "Restaurants" or "Beauty Parlours" for your launch city with business cards on, sort by `reviewCount` to start with busy outlets, and import `name`, `phone`, `whatsapp`, `email`, `area` into your CRM.

**3. Website and digital-marketing agency.** Businesses without a website are your best prospects. Export any category, filter `website` = empty and `rating` ≥ 4, and pitch the ones with many ratings and no site. `claimed = false` marks listings the owner has never taken over — another opening for an "online presence" offer.

**4. Dental, medical and lab-equipment distributors.** "Dentists", "Dental Clinics", "Pathology Labs", "Physiotherapists" per city give you the clinic, its address, opening hours and `yearEstablished`. Sort by `yearEstablished` to find the newest clinics first.

**5. Fintech and merchant lending.** Underwriters and sales teams prospect small merchants by category and pincode. `yearEstablished`, `reviewCount`, `rating` and `jdVerified` are quick signals of an established, active business.

**6. Market sizing and expansion planning.** How many gyms are there in Pune, and in which pincodes? Run list mode (business cards off — fastest and cheapest) with locality expansion, then count by `pincode` or `area`. Repeat for competing categories to find under-served localities.

**7. Franchise and retail-chain analysts.** Search a brand-relevant category ("Pizza Outlets", "Ice Cream Parlours") and group by `name` to map a chain's outlets and its independent competitors per locality.

**8. Packers and movers / logistics aggregators.** Build a supplier network: "Packers And Movers", "Transporters", "Courier Services" in every metro, with WhatsApp and e-mail for onboarding messages.

**9. Education counsellors and ed-tech partnerships.** "Coaching Classes", "IELTS Coaching", "Play Schools" by city with addresses, hours and contact numbers for partnership outreach.

**10. Wedding and event planners.** Combine "Banquet Halls", "Caterers", "Wedding Planners", "Decorators" and "Photographers" for one city into a vendor directory with ratings and phone numbers.

**11. Real-estate brokers and property portals.** "Estate Agents", "Builders And Developers", "Interior Designers" per city — the people you want on your platform or in your referral network.

**12. Local SEO consultants.** Ratings, number of ratings, tags such as *Top rated* or *Trending*, claimed status and the category list show how a client compares with every competitor in its locality — and which businesses need help with their listings.

**13. KYC and vendor verification.** Paste the Justdial page URLs of vendors you already have: the Actor returns each business card (address, numbers, year of establishment, claimed status) so your team can compare it with what the vendor declared.

### Cookbook — 14 ready-to-run inputs

Paste any of these into the **JSON** tab of the input form (or send it as the body of an API call). Every field not listed keeps its default.

**1. A quick test — 20 restaurants in Mumbai with full business cards**

```json
{ "categories": ["Restaurants"], "cities": ["Mumbai"], "maxItems": 20 }
```

**2. Thousands of restaurants in one city (deep run)**

```json
{ "categories": ["Restaurants"], "cities": ["Mumbai"], "maxItems": 10000, "includeDetails": false }
```

List mode is the fastest and cheapest way to map a whole city: name, call-button phone, address line, locality, pincode, GPS, rating, ratings, categories. Turn `includeDetails` on when you also need WhatsApp, e-mail, website and opening hours.

**3. Leads with contacts — dentists in two cities**

```json
{ "categories": ["Dentists"], "cities": ["Delhi", "Pune"], "maxItems": 2000 }
```

**4. Several categories in several cities (fair share)**

```json
{
  "categories": ["Plumbers", "Electricians", "Carpenters"],
  "cities": ["Bangalore", "Hyderabad", "Chennai"],
  "maxItems": 3000
}
```

The run gives every keyword × city a fair share: the search with the fewest businesses so far always goes next, so a small maximum still covers all nine searches.

**5. Only some localities of a city**

```json
{
  "categories": ["Cafes"],
  "cities": ["Bangalore"],
  "areas": ["Koramangala", "Indiranagar", "HSR Layout", "Whitefield"],
  "maxItems": 800
}
```

With `areas` set, only those localities are searched (no expansion into others).

**6. The city-wide top list only (no locality expansion)**

```json
{ "categories": ["Hospitals"], "cities": ["Chennai"], "expandAreas": false, "maxItems": 100 }
```

**7. Paste a Justdial search page**

```json
{ "startUrls": ["https://www.justdial.com/Mumbai/Restaurants-in-Andheri-West/nct-10408936"], "maxItems": 300 }
```

Any Justdial result-page URL works (`/City/Category/nct-…` or `/City/Category-in-Locality/nct-…`). A URL with a locality is read for that locality only; a city-wide one is expanded like a category × city search.

**8. Enrich business pages you already have**

```json
{
  "startUrls": [
    "https://www.justdial.com/Mumbai/Rosh-Ron-Restaurant-Off-Marve-Road-Malad-West/022P8010682_BZDET",
    "https://www.justdial.com/Thane/Sairaj-Hotel-Pakshal-Sangvi-Nagar-Mira-Road-East/022PXX22-XX22-131026163005-N2J4_BZDET"
  ]
}
```

**9. Chartered accountants and tax consultants (B2B services)**

```json
{ "categories": ["Chartered Accountants", "Tax Consultants", "GST Consultants"], "cities": ["Ahmedabad", "Surat"], "maxItems": 1500 }
```

**10. Wedding vendors for one city**

```json
{ "categories": ["Banquet Halls", "Caterers", "Wedding Planners", "Decorators"], "cities": ["Jaipur"], "maxItems": 1200 }
```

**11. Fitness — gyms and yoga in metros**

```json
{ "categories": ["Gyms", "Yoga Classes"], "cities": ["Mumbai", "Delhi", "Bangalore"], "maxItems": 3000 }
```

**12. Market sizing — count gyms by pincode (list mode)**

```json
{ "categories": ["Gyms"], "cities": ["Pune"], "includeDetails": false, "maxItems": 5000 }
```

Then group the dataset by `pincode` in Sheets or Excel.

**13. Education — coaching institutes**

```json
{ "categories": ["Coaching Classes", "IELTS Coaching"], "cities": ["Lucknow", "Jaipur"], "maxItems": 1000 }
```

**14. A cost-capped run**
Start any input with a **Maximum cost per run** (Console: *Run options → Maximum cost per run*, API: `maxTotalChargeUsd`). The Actor works out how many results the budget covers and stops cleanly there with a status message, instead of being cut off mid-way.

### Quick start in Apify Console

1. Open the Actor and go to the **Input** tab.
2. In **Categories / keywords**, type what you are looking for the way Justdial names it — *Restaurants*, *Plumbers*, *Dentists*, *Gyms*. One per line.
3. In **Cities**, type one or more Indian cities — *Mumbai*, *Delhi*, *Bangalore*… (*Bengaluru*, *New Delhi* and *Gurugram* are understood too).
4. Set **Max businesses**. Leave **Include business cards** on if you want WhatsApp, e-mail, website and opening hours; turn it off for the fastest list-only export.
5. Click **Start**. The first rows appear in the **Output** tab within seconds; the status line shows how many businesses, list calls, searches and business cards are done.
6. Open the **Overview**, **Contacts**, **Location** or **Business profile** view, or export everything as CSV, Excel or JSON.

### Quick start with the API

Run the Actor and get the results in one call (good for up to a few thousand rows):

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~justdial-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["Dentists"],"cities":["Pune"],"maxItems":200}'
```

**Node.js** (`npm install apify-client`):

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('logiover/justdial-scraper').call({
    categories: ['Plumbers', 'Electricians'],
    cities: ['Bangalore'],
    maxItems: 1000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const withContact = items.filter((b) => b.whatsapp || b.email);
console.log(`${items.length} businesses, ${withContact.length} with WhatsApp or e-mail`);
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("logiover/justdial-scraper").call(run_input={
    "categories": ["Chartered Accountants"],
    "cities": ["Ahmedabad"],
    "maxItems": 500,
})
for b in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(b["name"], b["phone"], b["phoneType"], b["email"], b["pincode"])
```

Download as CSV or Excel directly: `https://api.apify.com/v2/datasets/<datasetId>/items?format=csv` (or `format=xlsx`, `format=json`, `format=xml`). Add `&fields=name,phone,whatsapp,email,website,address,pincode` to pick columns, `&view=contacts` to use a prepared view.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `categories` | array of strings | — | What to search, the way Justdial names it: *Restaurants*, *Plumbers*, *Dentists*, *Chartered Accountants*, *Gyms*, *Packers And Movers*. Justdial maps the word to its own category. Every keyword is searched in every city. |
| `cities` | array of strings | — | Indian cities as Justdial spells them. *Bengaluru → Bangalore*, *New Delhi → Delhi*, *Gurugram → Gurgaon*, *Bombay → Mumbai*, *Calcutta → Kolkata*, *Madras → Chennai*, *Navi Mumbai → Navi-Mumbai*, *Mysuru → Mysore* are translated automatically. |
| `areas` | array of strings | empty | Search only these localities of each city (*Andheri West*, *Koramangala*, *Connaught Place*). When set, locality expansion is off. |
| `startUrls` | array of strings | empty | Justdial search pages (`/City/Category/nct-…`, also `-in-Locality`) and/or business pages (`…_BZDET`). Search pages are read like a category × city search; business pages return that business with its full card. Non-Justdial URLs are skipped with a note. |
| `maxItems` | integer | 1000 | Stop after this many unique businesses (all searches together). 1 – 1,000,000. |
| `includeDetails` | boolean | true | Open each business card for WhatsApp, e-mail, website, full address and state, opening hours, year of establishment, summary, services, all categories and claimed status. One extra call per business. Off = fastest list-only export. |
| `expandAreas` | boolean | true | Also search every locality the results reveal (each has its own ≈100-business list) and drop duplicates by docid. Off = only the city-wide top list. |
| `proxyConfiguration` | object | Apify Proxy | Leave as is: the Actor always uses Apify Residential proxies, because Justdial refuses datacenter and direct traffic. Put your own proxy URLs here only if you have residential proxies of your own. |

You need either **categories + cities** or **startUrls**. With only one of categories/cities, the run stops at once with `INVALID_INPUT` and says what is missing.

### Data dictionary

Fill rate = share of rows where the field is not empty, measured on the Apify platform on 2026-10-24 (UTC) in two runs: **A** = 1,000 businesses with default settings (business cards on) for Dentists, Plumbers, Chartered Accountants, Gyms and Packers And Movers in Delhi and Pune; **B** = 10,500 restaurants in Mumbai in list mode (business cards off, locality expansion on). Fields filled only from the business card are empty in list mode by design.

| Field | Type | Meaning | Fill A (cards on) | Fill B (list mode) | Example |
|---|---|---|---|---|---|
| `docid` | string | Justdial's permanent business id. Use it to deduplicate across runs and to join exports. | 100.0 % | 100.0 % | `022P8010682` |
| `name` | string | Business name as listed on Justdial. | 100.0 % | 100.0 % | `Rosh & Ron Restaurant` |
| `phone` | string | Best number to call: the Justdial call-button number if Justdial shows one, otherwise the business's WhatsApp number (national format). | 97.8 % | 3.0 % | `09845248771` |
| `phoneType` | string | Where `phone` comes from: `justdial_virtual_number` (Justdial's forwarding number for this business), `direct` (the business's own number on the call button) or `whatsapp` (no call-button number without a login; this is the business's WhatsApp number). | 97.8 % | 3.0 % | `justdial_virtual_number` |
| `phones` | array | Every number for the business in national format: call-button numbers first, then the WhatsApp number. | 97.8 % | 3.0 % | `["07208462154","09892203511"]` |
| `phonesInternational` | array | The same numbers in international (E.164) form where they are complete Indian numbers. | 97.8 % | 3.0 % | `["+917208462154"]` |
| `callButtonNumbers` | array | Only the numbers on Justdial's call button (empty for listings that hide them behind a login). | 91.0 % | 3.0 % | `["09845248771"]` |
| `whatsapp` | string | WhatsApp number from the business card, international form. | 97.6 % | 0.0 % | `+919892203511` |
| `email` | string | First e-mail address on the business card. | 89.1 % | 0.0 % | `ayubs.fort@gmail.com` |
| `emails` | array | All e-mail addresses on the business card. | 89.1 % | 0.0 % | `["info@kamatsindia.com"]` |
| `website` | string | First website on the business card. | 43.9 % | 0.0 % | `https://www.gajalee.com` |
| `websites` | array | All websites on the business card. | 43.9 % | 0.0 % | `["https://tanatan.co/"]` |
| `address` | string | Full postal address from the business card, with city, pincode and (except Delhi) state. | 100.0 % | 0.0 % | `A1/2/106, Pakshal Sangvi Nagar, Hatkesh Road, Mira Bhayander Road, Mira Road East, Thane-401107, Maharashtra` |
| `addressLine` | string | First address line Justdial prints on the result card (landmark / building + locality). | 100.0 % | 99.8 % | `Near Metro Pillar No 612 Vikaspuri` |
| `street` | string | Second address line on the result card (street + locality). | 99.6 % | 99.9 % | `Shankar Garden Vikaspuri` |
| `area` | string | Locality (Justdial's "area"). | 99.9 % | 99.8 % | `Malad West` |
| `city` | string | City of the business (Justdial's grouping: a Mumbai search also returns Thane, Navi Mumbai, Palghar…). | 100.0 % | 100.0 % | `Navi Mumbai` |
| `state` | string | State, taken from the end of the full address. Empty for Delhi addresses, which end with the pincode. | 70.7 % | 0.0 % | `Maharashtra` |
| `pincode` | string | 6-digit PIN code. | 100.0 % | 100.0 % | `400095` |
| `latitude` | number | Latitude of the business pin. | 100.0 % | 100.0 % | `19.1951667650209` |
| `longitude` | number | Longitude of the business pin. | 100.0 % | 100.0 % | `72.82477576654879` |
| `rating` | number | Justdial rating, 0–5 (empty when the business has no rating yet). | 97.8 % | 100.0 % | `4.1` |
| `reviewCount` | number | Exact number of ratings Justdial counts for the business. | 100.0 % | 100.0 % | `7963` |
| `primaryCategory` | string | The business's main Justdial category. | 100.0 % | 100.0 % | `North Indian Restaurants` |
| `primaryCategoryId` | string | Justdial's id of that category (the `nct-` number in Justdial URLs). | 100.0 % | 100.0 % | `10339065` |
| `categories` | array | Categories on the result card; for restaurants these are the cuisines. | 100.0 % | 99.9 % | `["Chinese","Sea Food","Sichuan"]` |
| `alsoListedIn` | array | Every Justdial category the business is listed in (business card). | 100.0 % | 0.0 % | `["Dentists","Dental Clinics"]` |
| `tags` | array | Justdial labels on the card: Top rated, Trending, Popular, Most searched… | 72.9 % | 53.5 % | `["Top rated","Trending"]` |
| `highlights` | array | Short notes on the card (call-pickup rate, offers, review snippets). | 22.0 % | 7.6 % | `["High call pick up rate"]` |
| `jdVerified` | boolean | Justdial's *JD Verified* flag. | 100.0 % | 100.0 % | `true` |
| `jdTrust` | boolean | Justdial's *JD Trust* flag. | 100.0 % | 100.0 % | `false` |
| `claimed` | boolean | `true` when the business card says *This Business is Claimed* (owner took over the listing); `false` when the card was read and has no such badge. | 100.0 % | 0.0 % | `true` |
| `openStatus` | string | Opening status as shown at the moment of scraping. | 41.8 % | 95.4 % | `Opens at 11:00 AM` |
| `businessHours` | string | Opening hours for each day of the week from the business card. | 98.6 % | 0.0 % | `SUN: 11:00 am - 12:30 am; MON: …` |
| `priceForTwo` | number | Restaurants only: Justdial's average price for two, in ₹. | 0.1 % | 58.0 % | `850` |
| `yearEstablished` | number | Year of establishment from the card's *Quick Information*. | 93.6 % | 0.0 % | `2012` |
| `businessSummary` | string | Justdial's one-sentence business summary. | 41.7 % | 0.0 % | `Restaurant specializing in Chinese cuisine and seafood…` |
| `services` | array | Services and amenities the business lists as available. | 77.1 % | 0.0 % | `["Home Delivery","Parking Available"]` |
| `photosCount` | number | Number of photos on the listing. | 100.0 % | 100.0 % | `131` |
| `thumbnail` | string | Main photo URL. | 100.0 % | 100.0 % | `https://content.jdmagicbox.com/…-250.jpg` |
| `photos` | array | Up to five photo URLs from the result card. | 100.0 % | 100.0 % | `["https://content.jdmagicbox.com/…"]` |
| `orderOnlineLinks` | array | Restaurants: the online-ordering links Justdial shows. | 9.9 % | 60.0 % | `["https://www.swiggy.com/restaurants/…"]` |
| `url` | string | Justdial business page. | 100.0 % | 100.0 % | `https://www.justdial.com/Mumbai/…/022P8010682_BZDET` |
| `shortUrl` | string | Justdial's short share link. | 100.0 % | 100.0 % | `https://www.justdial.com/DT-43ZPHVTR` |
| `searchKeyword` | string | The keyword / category of the search that found the business. | 100.0 % | 100.0 % | `Dentists` |
| `searchCity` | string | The city searched. | 100.0 % | 100.0 % | `Delhi` |
| `searchArea` | string | The locality list the business was read from (empty for the city-wide list). | 3.6 % | 99.1 % | `Andheri West` |
| `position` | number | Position of the business in that Justdial list. | 100.0 % | 100.0 % | `24` |
| `detailsScraped` | boolean | `true` when the business card was read for this row. | 100.0 % | 100.0 % | `true` |
| `scrapedAt` | string | When the run started reading (UTC, ISO 8601). | 100.0 % | 100.0 % | `2026-10-24T22:55:22.204Z` |

How to read the contact columns: in run A, `phone` was filled for 97.8 % of businesses — 88.2 % with a Justdial virtual number from the call button, 2.8 % with the business's own number on the call button, and 6.8 % with the business's WhatsApp number because Justdial showed no call-button number without a login. `email` was filled for 89.1 % and `website` for 43.9 %. Restaurants publish fewer e-mail addresses: in a 1,000-restaurant run in Bangalore with business cards on (2026-10-24), WhatsApp was filled for 90.5 %, e-mail for 42.0 % and website for 49.2 %. `priceForTwo` and `orderOnlineLinks` are restaurant fields (58.0 % and 60.0 % in run B, near zero in run A, which had no restaurants).

### Output sample

A real row from the measured run A (build 1.0.12, 2026-10-24), shown exactly as saved — nothing masked or shortened except the photo list (two of five URLs kept).

```json
{
  "docid": "011PXX11.XX11.220929130702.E2V8",
  "name": "Plush Dental Studio",
  "phone": "08485957463",
  "phoneType": "justdial_virtual_number",
  "phones": [
    "08485957463",
    "08287025128"
  ],
  "phonesInternational": [
    "+918485957463",
    "+918287025128"
  ],
  "callButtonNumbers": [
    "08485957463"
  ],
  "whatsapp": "+918287025128",
  "email": "plushdentalatudio@gmail.com",
  "emails": [
    "plushdentalatudio@gmail.com"
  ],
  "website": "https://www.plushdentalstudio.whitecoats.com",
  "websites": [
    "https://www.plushdentalstudio.whitecoats.com"
  ],
  "address": "Shop No -6, Lotus 300, Lotus 300, Next to Prateek Ediffice, Dadri Road, Sector 107, Noida-201304, Uttar Pradesh",
  "addressLine": "Next To Prateek Ediffice Noida Sector 107",
  "street": "Dadri Road Noida Sector 107",
  "area": "Noida Sector 107",
  "city": "Noida",
  "state": "Uttar Pradesh",
  "pincode": "201304",
  "latitude": 28.544794165156,
  "longitude": 77.37480406949,
  "rating": 4.9,
  "reviewCount": 72,
  "primaryCategory": "Clinics",
  "primaryCategoryId": "10101647",
  "categories": [
    "Clinics"
  ],
  "alsoListedIn": [
    "Dentists",
    "Clinics",
    "Dental Clinics",
    "Dental Surgeons",
    "Orthodontist Doctors",
    "Doctors For Dental Implantation",
    "Teeth Whitening Services",
    "Implantologist Doctors",
    "Paedodontist Doctors",
    "Maxillofacial Surgeon Doctors"
  ],
  "tags": [
    "Top rated"
  ],
  "highlights": [],
  "jdVerified": true,
  "jdTrust": false,
  "claimed": true,
  "openStatus": "Opens at 11:00 AM",
  "businessHours": "SUN: 11:00 am - 7:00 pm; MON: 10:00 am - 8:00 pm; TUE: 10:00 am - 8:00 pm; WED: 10:00 am - 8:00 pm; THU: 10:00 am - 8:00 pm; FRI: 10:00 am - 8:00 pm; SAT: 10:00 am - 8:00 pm",
  "priceForTwo": null,
  "yearEstablished": 2022,
  "businessSummary": "Dental clinic offering a comprehensive range of services including orthodontics, implants, and cosmetic dentistry.",
  "services": [
    "Dental Laser",
    "Composite Bondings",
    "Fixed Prosthodontics",
    "Dental Braces Fixing",
    "Ceramic Crowns and Bridges Fixing",
    "Bleeding Gums",
    "Wisdom Tooth Extraction",
    "RCT (Root Canal)",
    "Pulpectomy",
    "Oral And Maxillofacial",
    "Dental & Oral X-ray",
    "Ultrasonic Teeth Cleaning",
    "Advanced Preventive Dental Care",
    "Composite(Laser) Filing",
    "Gum care"
  ],
  "photosCount": 16,
  "thumbnail": "https://content.jdmagicbox.com/v2/comp/delhi/v8/011pxx11.xx11.220929130702.e2v8/catalogue/plush-dental-studio-nyay-khand-1-indirapuram-ghaziabad-dental-clinics-r964jiu0ow-250.jpg",
  "photos": [
    "https://content.jdmagicbox.com/v2/comp/delhi/v8/011pxx11.xx11.220929130702.e2v8/catalogue/plush-dental-studio-nyay-khand-1-indirapuram-ghaziabad-dental-clinics-r964jiu0ow-250.jpg",
    "https://content.jdmagicbox.com/v2/comp/delhi/v8/011pxx11.xx11.220929130702.e2v8/catalogue/plush-dental-studio-nyay-khand-1-indirapuram-ghaziabad-dental-clinics-esswcoz7yo-250.jpg"
  ],
  "orderOnlineLinks": [],
  "url": "https://www.justdial.com/Noida/Plush-Dental-Studio-Next-To-Prateek-Ediffice-Noida-Sector-107/011PXX11-XX11-220929130702-E2V8_BZDET",
  "shortUrl": "https://www.justdial.com/DT-23EKP6ZIIRL",
  "searchKeyword": "Dentists",
  "searchCity": "Delhi",
  "searchArea": null,
  "position": 24,
  "detailsScraped": true,
  "scrapedAt": "2026-10-24T22:55:22.204Z"
}
```

Six more rows from the same run, contact columns only (real values, unmasked):

| name | phone | phoneType | whatsapp | email | area, city | pincode | rating (ratings) | searched as |
|---|---|---|---|---|---|---|---|---|
| Reliable Services | 07383371942 | justdial_virtual_number | +919503445834 | balajiconstructionsatish@gmail.com | Pimple Saudagar, Pune | 411027 | 4.5 (55) | Plumbers / Pune |
| Bharat Bhaskar & Co. | 08147164456 | justdial_virtual_number | +917428911068 | cabharatbhaskar.co@gmail.com | Rani Bagh, Delhi | 110034 | 4.4 (32) | Chartered Accountants / Delhi |
| Eleplace.in | 09724251368 | justdial_virtual_number | +919833370122 | elesales@eleplace.in | Handewadi, Pune | 411028 | 4.5 (1148) | Packers And Movers / Pune |
| Enduro Fitness LLP | 09035098936 | justdial_virtual_number | +919960331154 | enduro2849@rediffmail.com | Sahakar Nagar-Parvati Darshan, Pune | 411009 | 3.8 (247) | Gyms / Pune |
| Dr. Satras Dental Clinic | 09035152647 | justdial_virtual_number | +918308803414 | shweta.tambe90@gmail.com | Pimple Gurav, Pune | 411061 | 4.8 (295) | Dentists / Pune |
| Dharmender Plumbing Services | 09740135528 | justdial_virtual_number | +919990771658 | nikkuchauhan9260@gmail.com | Gurgaon Sector 45, Gurgaon | 122003 | 4.8 (17) | Plumbers / Delhi |

### CSV and Excel columns

CSV, Excel and HTML exports have one column per field, in the order of the [data dictionary](#data-dictionary) (`docid`, `name`, `phone`, `phoneType`, … `scrapedAt`).

Array fields (`phones`, `emails`, `websites`, `categories`, `alsoListedIn`, `tags`, `highlights`, `services`, `photos`, `orderOnlineLinks`, `phonesInternational`, `callButtonNumbers`) become numbered columns in CSV/Excel (`phones/0`, `phones/1`, …). If you prefer one cell per field, use JSON, or download with `&fields=` to keep only the columns you need — `phone`, `whatsapp`, `email` and `website` are already single-value columns for exactly that reason.

### Scale and speed

All measurements were made on the Apify platform with the Actor's default memory (1,024 MB), on the dates shown (UTC). Times are the platform's own run durations, from start to finish.

| Date | Input | Settings | Result | Duration |
|---|---|---|---|---|
| 2026-10-24 | Restaurants × Mumbai | defaults, 20 businesses (the input form's prefill) | 20 businesses with full business cards, first row after 1.9 s | 18.8 s |
| 2026-10-24 | Dentists, Plumbers, Chartered Accountants, Gyms, Packers And Movers × Delhi, Pune | defaults (business cards on), max 1,000 | 1,000 unique businesses, 10 searches, 33 Justdial lists, 1,000 business cards | 62.0 s |
| 2026-10-24 | Restaurants × Bengaluru | defaults (business cards on), max 1,000 | 1,000 unique businesses from 13 locality lists | 77.6 s |
| 2026-10-24 | Restaurants × Mumbai | list mode, max 1,500 | 1,500 unique businesses, 0 duplicates | 58.4 s |
| 2026-10-24 | Restaurants × Mumbai | list mode, max 10,500 | **10,500 unique businesses, 0 duplicates**, 1,262 localities searched out of 1,566 found | 354.9 s |
| 2026-10-24 | 28 categories × Jaipur | list mode, no locality expansion, max 280 | 280 businesses, every keyword resolved to a Justdial category | 10.9 s |

What the numbers mean for planning:

- **With business cards on**, expect roughly 1,000 businesses per minute: every business costs one extra call, and twenty are read in parallel.
- **In list mode**, deep single-category crawls of Mumbai ran at about 1,500–1,800 businesses per minute (1,500 in 58.4 s, 10,500 in 354.9 s); a crawl slows down as newly found localities yield fewer new businesses, because more of them were already collected from neighbouring localities.
- **How deep can one search go?** Justdial serves about 100 businesses per list. A big city × big category has hundreds of localities — Mumbai restaurants showed 1,566 — so tens of thousands are reachable. Small categories in small cities run out sooner; the run then ends with *every list read, all localities found*.

### Data quality checks

Every column was checked against the source before release:

- **Duplicates:** 0 in every measured run, checked independently on the platform (10,500 / 10,500 unique docids in the biggest run).
- **Hand spot-check, 12 businesses (Bangalore restaurants, 2026-10-25):** every row was compared with Justdial's own page (as indexed by search engines) and with independent public sources — other directories and the businesses' own websites and social pages. Names, localities and pincodes agreed wherever a record exists. The call-button numbers matched Justdial's pages (3 of 3 checked). 11 of the 12 have a WhatsApp number: for 9 it is published elsewhere as the business's own phone, the other 2 (a small and a very new business) have no independent record, and none was contradicted. Full street addresses agreed for 7; for 3, other directories print an older or different street line (the row keeps the address the business gave Justdial); 2 could not be checked. E-mail addresses: 2 of the 5 checked are also published by the business elsewhere; the other 3 appear only on Justdial (owners often register a personal address there). Websites: 4 of 6 confirmed on the business's own pages.
- **Earlier checks (Mumbai, 2026-10-24):** for *Rosh & Ron Restaurant* (Malad West) the numbers 07208462154 and 09892203511 and its full address match independent listings; *Sairaj Hotel* (Mira Road East) shows 09845248771 on Justdial's own page, as in the data; *Gajalee Sea Food Restaurant* and *Kamats Legacy* WhatsApp numbers are the restaurants' published phone numbers.
- **A trap that is avoided:** Justdial answers a business-card request that does not look exactly like its own page's request with a complete-looking card whose phone numbers are made up (one of them was nine digits long, none existed anywhere else). The Actor sends the page's exact request, and on top of that uses card phone numbers only when they agree with the result list. Every measured run reported 0 mismatches.
- **Types:** numbers are numbers (`rating`, `reviewCount`, `latitude`, `longitude`, `priceForTwo`, `yearEstablished`, `photosCount`, `position`), flags are booleans, lists are arrays, URLs are absolute, `scrapedAt` is ISO 8601 UTC, text has no HTML.

### Pricing

This Actor is **pay per result**: you pay for each business saved to the dataset, nothing for searches, retries, proxies or business cards.

| Apify plan | Price per 1,000 businesses |
|---|---|
| Free | $3.00 |
| Bronze | $2.67 |
| Silver | $2.33 |
| Gold, Platinum, Diamond | $2.00 |

**What you pay:**

| Businesses | Free plan | Gold plan and above |
|---|---|---|
| 1,000 | $3.00 | $2.00 |
| 10,000 | $30.00 | $20.00 |
| 100,000 | $300.00 | $200.00 |

The same business found again in another locality or another keyword search of the same run is **not** saved or charged again.

**Maximum cost per run.** Every pay-per-result run has a cost ceiling — the one you set in *Run options → Maximum cost per run* (API: `maxTotalChargeUsd`), or the platform's default when you set none. The Actor reads that ceiling when it starts, works out how many businesses it covers at your price, and stops cleanly when they are saved — with the status message *"Saved N businesses — this run's maximum cost ($X) is used up at the current price. Raise "Maximum cost per run" to get more."* — so you are never charged beyond your ceiling and the run never ends as *Aborted*. For big runs (tens of thousands of businesses), raise the ceiling accordingly: at the Free-plan price, 10,000 businesses need $30.

### Integrations

- **REST API / curl** — `POST /v2/acts/logiover~justdial-scraper/runs` starts a run; `run-sync-get-dataset-items` runs and returns the rows in one call (see [Quick start with the API](#quick-start-with-the-api)).
- **Node.js and Python** — the official `apify-client` packages: `client.actor('logiover/justdial-scraper').call(input)`, then read `defaultDatasetId`.
- **Make (Integromat)** — the Apify app's *Run an Actor* module, then *Get dataset items*; map `name`, `phone`, `whatsapp`, `email` to your CRM, Google Sheets or WhatsApp-sending module.
- **Zapier** — *Apify → Run Actor* as an action, *Apify → Finished Actor Run* as a trigger; send every new business to HubSpot, Pipedrive, Zoho CRM, Airtable or a spreadsheet.
- **n8n** — the Apify node (or an HTTP Request node with the run-sync endpoint) inside any workflow; dedupe on `docid` before inserting.
- **Google Sheets** — Apify's Google Sheets integration on the Actor's *Integrations* tab appends the dataset to a sheet after every run; or `=IMPORTDATA("https://api.apify.com/v2/datasets/<id>/items?format=csv&clean=1")`.
- **Airtable** — through Zapier or Make; use `docid` as the primary field.
- **Webhooks** — add a webhook for *Run succeeded* to receive the run and dataset ids the moment a run ends.
- **Schedules** — create a schedule (daily, weekly, monthly) with your input to track new businesses in your categories; compare `docid` lists between runs to find new and removed listings.
- **AI agents and MCP** — through the Apify MCP server an AI assistant can call this Actor as a tool ("find 200 dentists in Pune with e-mail") and read the rows back.
- **Data warehouses** — export the dataset as JSON or CSV to S3, Google Cloud Storage, BigQuery or Snowflake with Apify's integrations or a small script on the dataset items endpoint.

### Performance tips

- **Need only names, numbers on the call button, locality and pincode?** Turn `includeDetails` off. It is several times faster and the right choice for counting and market maps.
- **Need contacts?** Keep business cards on: WhatsApp, e-mail and website come only from the card.
- **Going deep in one city?** Keep `expandAreas` on and set `maxItems` to what you need; the run stops as soon as it has them.
- **Exact localities only?** Use `areas` — it is faster than expanding the whole city and returns only what you asked for.
- **Many keywords?** Put them all in one run: lists already read are not read twice and duplicates are not charged.
- **Big runs:** set *Maximum cost per run* high enough (see [Pricing](#pricing)) and leave the default timeout (one hour) or raise it for 50,000+ businesses with business cards.

### Troubleshooting

Every message the Actor can finish with, and what to do:

| Status message | Outcome | Meaning / what to do |
|---|---|---|
| *Saved N businesses (max results reached) from M Justdial lists in T s.* | Succeeded | Your maximum was reached. Raise `maxItems` for more. |
| *Saved N businesses (every list read, all localities found) …* | Succeeded | Everything Justdial shows for the search was read. For more, add related categories or nearby cities. |
| *Saved N businesses (stopped at the run time limit) …* | Succeeded | The run's timeout came first. Raise the timeout in *Run options*. |
| *… · K without business-card details (Justdial did not answer)* | Succeeded | Those rows have list data but no card fields; run them again later by pasting their `url`s into `startUrls`. |
| *… · K list call(s) could not be read.* | Succeeded (partial) | A few list calls were refused even after fresh residential IPs; all other rows are complete. Running the same input again fills the gap. |
| *Saved N businesses — this run's maximum cost ($X) is used up at the current price. Raise "Maximum cost per run" to get more.* | Succeeded | Your cost ceiling was reached; see [Pricing](#pricing). |
| *Saved 0 businesses — this run's maximum cost ($X) does not cover a single result …* | Succeeded | The ceiling is below the price of one business. Raise it. |
| *Justdial has no "X" list for "Y" (it redirects to …) — check the city / category spelling.* | Succeeded (empty) | Justdial does not know the city (or the keyword) as written. Use Justdial's spelling — e.g. *Bangalore*, *Gurgaon* — or paste a Justdial search URL for that place. |
| *Justdial returned no businesses for "X" in Y.* / *Justdial answered but returned no businesses for these searches …* | Succeeded (empty) | The search is valid but empty, e.g. a very specific category in a small town. |
| *No businesses collected: no page could be fetched (…) after N attempt(s). This is a source-access failure, not an empty result …* | Failed | Justdial's firewall refused every attempt, each from a fresh residential IP. Temporary — run again in a few minutes. |
| *No businesses collected and N page(s) could not be read, so an empty result cannot be confirmed.* | Failed | Some calls were answered, none had businesses, others failed. Run again. |
| *INVALID_INPUT: Add at least one city …* / *Add at least one category or keyword …* / *Nothing to do …* / *None of the start URLs is a Justdial search or business page.* | Failed | The input is incomplete; fix it as the message says. |
| *Crashed after saving N businesses: …* | Failed | Unexpected error; the rows saved so far are kept. Please send us the run link. |

Every run also writes a **SUMMARY** record to its key-value store: outcome, rows saved, each search with the category id Justdial resolved, localities searched and found, business cards read and the reason for stopping.

### Honest limits

- **About 100 businesses per Justdial list.** Locality expansion goes far beyond that, but the Actor can only return businesses Justdial itself lists for your category in some locality of the city. Two identical runs return largely — not exactly — the same businesses, because Justdial re-samples its lists on every request; deduplicate on `docid` when merging runs.
- **Phone numbers are what Justdial shows.** Many paid listings show a *Justdial virtual number* — a number Justdial owns that forwards calls to the business (marked `justdial_virtual_number`). Free listings hide the call number behind Justdial's OTP login (*Show Number*); the Actor does not log in, so for them `phone` is the business's WhatsApp number from its card when it has one (`phoneType: whatsapp`), and empty when it has neither.
- **No review texts.** Rating and the exact number of ratings are exported; individual reviews are not.
- **GSTIN is not exported.** Justdial itself shows it masked (`27**********1ZE`).
- **State** is empty for Delhi addresses (they end with the pincode) and when Justdial's address has no state.
- **`openStatus`** is a snapshot of the moment the business was read; `businessHours` is the stable weekly schedule.
- **Cities Justdial does not know as written** return an empty result with a clear message (for example, *Kota* is redirected by Justdial to Mumbai); use Justdial's spelling or paste a search URL.
- **Residential proxies are required** and are used automatically; datacenter and direct connections are refused by Justdial.

### Compared with other ways to get Justdial data

| Way | What you get | Effort |
|---|---|---|
| **Justdial website or app by hand** | Everything on screen, one business at a time; phone numbers of many listings only after an OTP login | Hours per hundred businesses; no export |
| **Official Justdial API** | Justdial publishes no public API for its business listings | — |
| **Justdial's own paid lead products** | Enquiries Justdial routes to *your* business when you advertise with it | You receive leads, you do not get a list of businesses |
| **Buying a ready-made business database** | A one-off file of unknown date and coverage | No control over freshness, category or locality |
| **This Actor** | Every business Justdial lists for your categories and cities, with contacts, address, GPS, ratings, hours and categories, as CSV/Excel/JSON or via API | Type a category and a city; schedule it for fresh data |

### FAQ

#### How do I scrape Justdial?

Open the Actor, type a category (for example *Restaurants*) and a city (*Mumbai*), set how many businesses you want and click **Start**. The rows appear in the Output tab within seconds and can be downloaded as CSV, Excel or JSON. No code, no login and no Justdial account are needed.

#### Does Justdial have an API?

Justdial does not publish a public API for its business listings. This Actor is a practical Justdial API alternative: it reads the same JSON calls Justdial's mobile website makes and returns them as clean rows, and you can call it through the Apify API from any language.

#### How do I download Justdial data to Excel?

Run the Actor, open the dataset and choose **Export → Excel** (or CSV). Through the API, use `…/datasets/<id>/items?format=xlsx`.

#### Can I get phone numbers from Justdial?

Yes — every number Justdial shows without a login. For listings with a number on Justdial's Call button the Actor returns it (many are Justdial virtual numbers that forward to the business, marked `justdial_virtual_number`). For listings that hide the call number behind Justdial's OTP login, the Actor returns the business's WhatsApp number from its business card when it has one. In a measured 1,000-business run, 97.8 % of rows had a phone number.

#### What is a Justdial virtual number?

A number owned by Justdial and assigned to a business; calls to it are forwarded to the business. It is a working number that reaches the business, and it is the number Justdial itself displays. The Actor marks it with `phoneType: justdial_virtual_number` so you can tell it apart from the business's own number.

#### Can I get e-mail addresses from Justdial?

Yes, when the business has one on its Justdial business card. Keep *Include business cards* on. In a measured run of service businesses (dentists, plumbers, chartered accountants, gyms, movers in Delhi and Pune) 89.1 % had an e-mail address; for restaurants in Bangalore it was 42.0 %.

#### Can I get WhatsApp numbers?

Yes — the `whatsapp` column, from the business card (97.6 % of rows in the measured service-business run, 90.5 % for Bangalore restaurants).

#### How many results can I get from one Justdial search?

Justdial shows about 100 businesses per list. With locality expansion (on by default) the Actor also searches every locality it finds, so a big city and category goes far beyond 100 — measured: 10,500 unique restaurants in Mumbai in one run, with 0 duplicates.

#### How do I get all businesses of a category in a city?

Use the category and city, leave *Expand into localities* on and set *Max businesses* high (for example 50,000). The run stops when every locality it finds has been read, with the message *every list read, all localities found*.

#### Can I search several cities and categories at once?

Yes. Every keyword is searched in every city; the run shares the maximum fairly between all of them, and a business found by two searches is saved once.

#### Can I scrape only certain localities?

Yes — list them in **Localities**, e.g. *Andheri West*, *Bandra West*. Only those are searched.

#### Can I paste a Justdial URL?

Yes. Paste search pages (`https://www.justdial.com/Mumbai/Restaurants/nct-10408936`, also with `-in-<Locality>`) or business pages (`…_BZDET`) into **Justdial URLs**.

#### Which cities are supported?

Any city Justdial lists, spelled the way Justdial spells it: Mumbai, Delhi, Bangalore, Hyderabad, Chennai, Kolkata, Pune, Ahmedabad, Surat, Jaipur, Lucknow, Noida, Gurgaon, Navi Mumbai, Chandigarh, Indore, Nagpur, Kochi and many more were tested. Common alternatives (Bengaluru, New Delhi, Gurugram, Bombay, Calcutta, Madras, Mysuru) are translated automatically.

#### What do I type as a category?

The way Justdial names it: *Restaurants*, *Plumbers*, *Electricians*, *Dentists*, *Hospitals*, *Gyms*, *Beauty Parlours*, *Chartered Accountants*, *Tax Consultants*, *Packers And Movers*, *Car Repair And Services*, *Coaching Classes*, *Banquet Halls*, *Caterers*, *Interior Designers*, *Estate Agents*… Justdial maps the word to its own category; the category id it chose is written into the run's SUMMARY record.

#### Is a Justdial login or account needed?

No. Nothing is logged in; the Actor reads what Justdial shows to every visitor.

#### Do I need my own proxies?

No. Justdial refuses datacenter and direct traffic, so the Actor uses Apify Residential proxies automatically and replaces refused IPs within a fraction of a second.

#### How fast is it?

Measured on the Apify platform: 20 businesses with full business cards in 18.8 s (first row after 1.9 s); 1,000 businesses with full business cards in 62.0 s; 10,500 businesses in list mode in 354.9 s.

#### How much does it cost to scrape 10,000 Justdial listings?

$30 on the Free plan, $20 on Gold and higher plans (pay per result: $3.00 per 1,000 down to $2.00 per 1,000). Duplicates are not charged.

#### What happens when my run hits the maximum cost?

The Actor stops cleanly at the number of businesses your ceiling covers and says so in its status message; nothing beyond your ceiling is charged and the run does not end as *Aborted*.

#### Why does my run return fewer businesses than Justdial's "Results for your search" number?

That number is Justdial's estimate of all matching businesses; Justdial itself serves about 100 per list. Locality expansion reaches many more, but the Actor can return only businesses that appear in some Justdial list for your category in that city.

#### Why are two runs of the same input slightly different?

Justdial re-samples its result lists on every request. Most businesses repeat; some appear in one run and not the other. Merge runs on `docid`.

#### Does it return reviews?

It returns the rating and the exact number of ratings. Individual review texts are not exported.

#### Does it return opening hours?

Yes — `businessHours` (every day of the week, from the business card) and `openStatus` (the status shown at the moment of scraping).

#### Can I get the GST number?

No. Justdial shows GSTIN numbers masked, so there is nothing to export.

#### Does it get the full address with pincode?

Yes. `address` is the full postal address from the business card (city, pincode and, outside Delhi, the state); `pincode` is always a separate 6-digit column, and `latitude` / `longitude` give the map position.

#### Can I use it for B2B lead generation?

Yes — that is its main use: business name, phone, WhatsApp, e-mail, website, address, category and size signals (ratings, year of establishment) for any category and city. Check the rules for contacting businesses (see [Is it legal to scrape Justdial?](#is-it-legal-to-scrape-justdial)).

#### Can I schedule it to find new businesses every week?

Yes. Create a schedule with your input and compare each run's `docid` list with the previous one.

#### Can I use it from Python?

Yes — `pip install apify-client`, then `client.actor("logiover/justdial-scraper").call(run_input={...})`. See [Quick start with the API](#quick-start-with-the-api).

#### Does it work for Justdial in Hindi or other languages?

The data is read in English, Justdial's default language. Business names appear as the business wrote them.

#### What if Justdial changes its website?

The Actor reads Justdial's own JSON calls and checks every answer (a refused or empty answer is never saved as an empty result). If Justdial changes something, runs fail with a clear message instead of returning wrong data, and the Actor is updated.

### Glossary

| Term | Meaning |
|---|---|
| **Justdial (JD)** | India's largest local search directory: businesses, services, products, reviews. |
| **docid** | Justdial's id of a business listing, e.g. `022P8010682`. In URLs the dots become dashes. |
| **nct id / national category id** | Justdial's category number, the `nct-10408936` in search URLs (`primaryCategoryId`). |
| **BZDET page** | A Justdial business page; its URL ends with `_BZDET`. |
| **Area / locality** | A neighbourhood of a city as Justdial lists it (Andheri West, Koramangala, Vikaspuri). |
| **Pincode** | India's 6-digit postal code (PIN, Postal Index Number). |
| **Virtual number (VN)** | A Justdial-owned number that forwards calls to the business (`justdial_virtual_number`). |
| **Show Number** | Justdial's button that reveals a hidden phone number after an OTP login. In Justdial's Indian-language versions its label carries the local word for "number": *नंबर* (Hindi), *ನಂಬರ್* (Kannada), *நம்பர்* (Tamil), *નંબર* (Gujarati), *নম্বর* (Bengali). |
| **Business card** | The details view of a listing: full address, contacts, hours, *Quick Information*, services. |
| **Quick Information** | The card section with year of establishment, website, average cost and similar facts. |
| **JD Verified** | Justdial's verification badge (`jdVerified`). |
| **JD Trust** | Justdial's trust badge (`jdTrust`). |
| **Claimed** | The owner has claimed the listing (*This Business is Claimed*). |
| **Top rated / Trending / Popular / Most searched** | Justdial's labels on result cards (`tags`). |
| **Price for two** | Justdial's average restaurant bill for two people, in ₹. |
| **Also listed in** | Every Justdial category a business appears in (`alsoListedIn`). |
| **DPDP Act** | India's Digital Personal Data Protection Act, 2023. |
| **DND / NCPR** | India's Do-Not-Disturb registry (National Customer Preference Register) for commercial calls and SMS. |

### Is it legal to scrape Justdial?

This Actor reads business information that Justdial publishes openly to every visitor — business names, addresses, categories, ratings and the contact details businesses list for customers. It does not log in, does not bypass a paywall and does not read private user data.

How you use the data is your responsibility:

- **Personal data.** Many Indian businesses are run by individuals, so a phone number, WhatsApp number or e-mail address can identify a person. If you store or use it, India's **Digital Personal Data Protection Act, 2023 (DPDP Act)** may apply — collect only what you need, use it for a clear purpose, and honour requests to stop. If you are in the EU/UK or process data of people there, the **GDPR** applies as well.
- **Calls, SMS and WhatsApp.** Commercial calls and messages in India are regulated by TRAI's rules on unsolicited commercial communication; check numbers against the DND / NCPR registry before telemarketing, and follow WhatsApp's business messaging policies.
- **Justdial's terms.** Read Justdial's terms of use and respect them in how you use and republish the data.

This is general information, not legal advice. When in doubt, ask a lawyer about your specific use.

### Changelog

**1.0 — 2026-10-25**

- First release: Justdial business listings by category × city, localities and pasted Justdial search or business URLs.
- Locality expansion past Justdial's ≈100-per-list limit, with docid de-duplication (measured 10,500 unique restaurants in Mumbai, 0 duplicates).
- Business cards: WhatsApp, e-mail, website, full address with state, opening hours, year of establishment, summary, services, all categories, claimed badge.
- Phone numbers as Justdial shows them, with Justdial virtual numbers flagged and WhatsApp as the fallback contact number.
- Automatic Apify Residential routing with cookie-aware sessions, kept-alive connections and per-route success tracking; decoy-number protection on business cards.
- Pay per result with a clean stop at the run's maximum cost; SUMMARY record and explicit outcome messages; a run moved to another server skips the businesses it already saved.

### Support

Questions, a city or category that does not work, or a field you need? Open an issue on the Actor's **Issues** tab or message us through Apify — **we reply within 24 hours**. Please include the run link; the run's SUMMARY record tells us exactly what Justdial answered.

# Changelog

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

# Actor input Schema

## `categories` (type: `array`):

What to look for, the way Justdial names it: Restaurants, Plumbers, Dentists, Chartered Accountants, Gyms, Packers And Movers, Car Repair… Justdial resolves the word to its own category itself. Every keyword is searched in every city.

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

Indian cities as Justdial spells them: Mumbai, Delhi, Bangalore, Hyderabad, Chennai, Kolkata, Pune, Ahmedabad, Jaipur, Surat, Lucknow… Common alternative spellings (Bengaluru, New Delhi, Gurugram) are translated automatically.

## `areas` (type: `array`):

Search only these localities of each city, e.g. Andheri West, Bandra West, Koramangala, Connaught Place. Leave empty to search the whole city (with locality expansion below).

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

Paste Justdial search pages (https://www.justdial.com/Mumbai/Restaurants/nct-10408936, also with -in-<Locality>) and/or business pages (…\_BZDET). Search pages are read like a category × city search; business pages return that business with its full card.

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

Stop after this many unique businesses in total (all searches together). Justdial shows about 100 per list; with locality expansion a big city × category gives thousands.

## `includeDetails` (type: `boolean`):

Opens every business's Justdial card for the full postal address with state, e-mail address(es), website(s), WhatsApp number, opening hours for each day, year of establishment, business summary, services/amenities, all phone numbers and the categories it is also listed in. One extra call per business — turn off for the fastest list-only export (phone, address line, pincode, GPS, rating, reviews, categories stay).

## `expandAreas` (type: `boolean`):

Justdial serves about 100 businesses per search. With this on, every locality the results reveal (Andheri West, Malad West, Thane West…) is searched too and duplicates are dropped by Justdial's id — this is how one city × category reaches thousands of businesses. Turn off to get only the city-wide top list.

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

Justdial refuses datacenter and direct traffic (HTTP 403 "Access Denied"). The Actor therefore always uses Apify Residential proxies (worldwide pool, with India in rotation — whichever answers better during the run). Set your own proxy URLs here only if you have residential proxies of your own.

## Actor input object example

```json
{
  "categories": [
    "Restaurants"
  ],
  "cities": [
    "Mumbai"
  ],
  "areas": [],
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "expandAreas": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All Justdial businesses collected in this run.

# 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 = {
    "categories": [
        "Restaurants"
    ],
    "cities": [
        "Mumbai"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "categories": ["Restaurants"],
    "cities": ["Mumbai"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "categories": [
    "Restaurants"
  ],
  "cities": [
    "Mumbai"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call logiover/justdial-scraper --silent --output-dataset

```

## MCP server setup

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