# JustDial Business Leads Scraper (`automation-lab/justdial-leads-scraper`) Actor

Extract business leads from JustDial — India's largest local directory with 30M+ listings. Get name, phone, address, rating, and reviews for B2B prospecting.

- **URL**: https://apify.com/automation-lab/justdial-leads-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## JustDial Business Leads Scraper

Extract verified business leads from **JustDial** — India's largest local business directory with 30M+ listings. Collect business names, phone numbers, addresses, ratings, reviews, and more for B2B prospecting, market research, and competitive analysis.

### 🌟 What does it do?

This actor crawls JustDial search result pages for any city + category combination in India and extracts structured business lead data. Supply a list of search queries — for example "Restaurants in Mumbai" or "IT Companies in Bangalore" — and receive a clean, export-ready dataset within minutes.

No manual searching. No copy-pasting. Just actionable B2B lead lists.

### 👤 Who is it for?

- **B2B sales teams** targeting Indian SMEs — build contact lists for any vertical and city in minutes
- **Lead generation agencies** serving Indian clients — produce verified, categorised lead sheets at scale
- **Market researchers** mapping the competitive landscape — understand who is operating in any city and niche
- **Recruiters** sourcing from SMB employers — find IT, finance, and healthcare firms in target cities
- **CRM managers** enriching existing databases — add phone, address, and rating data to company records
- **Entrepreneurs** doing pre-launch validation — see who is already in a market and how well-rated they are

### 💡 Why use it?

JustDial has the most comprehensive coverage of Indian local businesses — significantly more than Google Maps for SME listings in Tier 2 and Tier 3 cities. Phone numbers on JustDial are verified by the platform, making them far more reliable than other lead sources.

- ✅ 30M+ listings across India
- ✅ Verified phone numbers included
- ✅ Ratings and review counts for lead qualification
- ✅ Supports any city + category combination
- ✅ Handles pagination automatically — scrape 10 or 1000 results per search

### 📊 Data extracted per business

| Field | Description | Example |
|-------|-------------|---------|
| `name` | Business name | "Afzal's Mao Restaurant" |
| `phone` | Primary phone number | "09972349574" |
| `category` | Business category | "Restaurants" |
| `address` | Street address or locality | "Carnac Road Masjid Bunder, Mumbai" |
| `locality` | Neighbourhood/area | "Masjid Bunder, Mumbai" |
| `city` | City | "Mumbai" |
| `pincode` | Postal code (when available) | "400003" |
| `rating` | Average rating (0–5) | 4.1 |
| `reviewCount` | Total ratings count | 507 |
| `website` | Business website (when listed) | "https://example.com" |
| `verified` | JustDial verified badge | true |
| `services` | Service tags/keywords | ["North Indian", "Chinese"] |
| `imageUrl` | Primary listing image URL | "https://content.jdmagicbox.com/..." |
| `listingUrl` | Full JustDial listing URL | "https://www.justdial.com/Mumbai/..." |
| `searchCity` | City used in search | "Mumbai" |
| `searchCategory` | Category used in search | "Restaurants" |
| `scrapedAt` | Extraction timestamp (ISO) | "2026-05-12T08:23:51.120Z" |

### 💰 How much does it cost to scrape JustDial leads?

This actor uses **pay-per-event pricing** — you only pay for results actually extracted.

| Usage tier | Price per lead |
|------------|---------------|
| Free (first 1,000/month) | $0.0035 |
| Bronze (1K–50K/month) | $0.0030 |
| Silver (50K–200K/month) | $0.0023 |
| Gold (200K–500K/month) | $0.0018 |
| Platinum (500K–2M/month) | $0.0012 |
| Diamond (2M+/month) | $0.00084 |

**Example costs:**
- 100 leads (one small search): ~$0.38 including run start fee
- 1,000 leads (10 city+category searches): ~$3.28
- 10,000 leads (bulk lead list): ~$27.50

Compared to purchased lead lists at $0.50–$2.00/contact, this actor delivers verified Indian business leads at 10–40× lower cost.

### 🚀 How to use it

1. **Open the actor** on Apify and click **Try for free**
2. **Add your searches** — enter city and category pairs (e.g., `{"city": "Mumbai", "category": "Restaurants"}`)
3. **Set the result limit** — `maxResultsPerSearch` controls how many leads to collect per search (default: 100)
4. **Run** — the actor fetches results and outputs a clean dataset
5. **Export** — download as CSV, JSON, or connect to Google Sheets / your CRM

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searches` | Array | `[{"city":"Mumbai","category":"Restaurants"}]` | List of city + category search pairs |
| `urls` | Array | — | Direct JustDial search page URLs (alternative to searches) |
| `maxResultsPerSearch` | Integer | 100 | Maximum leads to collect per search query |
| `includePhoneNumbers` | Boolean | `true` | Whether to extract phone numbers |
| `maxConcurrency` | Integer | 2 | Parallel page requests (keep ≤3 for stability) |
| `maxRetries` | Integer | 3 | Retry attempts per failed page |
| `proxyConfiguration` | Object | RESIDENTIAL (India) | Proxy settings — defaults to Indian residential proxy required by JustDial |

#### Common city names

Mumbai, Delhi, Bangalore, Chennai, Hyderabad, Pune, Kolkata, Ahmedabad, Jaipur, Surat, Lucknow, Kanpur, Nagpur, Indore, Thane, Bhopal, Visakhapatnam, Pimpri-Chinchwad, Patna, Vadodara, Ghaziabad, Ludhiana, Agra, Nashik, Faridabad, Meerut, Rajkot, Kalyan-Dombivali, Vasai-Virar, Varanasi

#### Common category examples

Restaurants, Dentists, IT-Companies, Hotels, Hospitals, Gyms, Lawyers, Chartered-Accountants, Real-Estate-Agents, Schools, Colleges, Plumbers, Electricians, Architects, Caterers, Event-Management-Companies, Digital-Marketing-Agencies

### 📤 Output format

Each item in the dataset represents one business listing:

```json
{
  "name": "Afzal's Mao Restaurant",
  "phone": "09972349574",
  "category": "Restaurants",
  "address": "Carnac Road Masjid Bunder, Mumbai",
  "locality": "Carnac Road Masjid Bunder, Mumbai",
  "city": "Mumbai",
  "pincode": "",
  "rating": 4.1,
  "reviewCount": 507,
  "website": "",
  "verified": false,
  "services": [],
  "imageUrl": "https://content.jdmagicbox.com/v2/comp/mumbai/...",
  "listingUrl": "https://www.justdial.com/Mumbai/Afzals-Mao-Restaurant-.../022PXX22-...",
  "searchCity": "Mumbai",
  "searchCategory": "Restaurants",
  "scrapedAt": "2026-05-12T08:23:51.120Z"
}
````

### 💡 Tips for best results

- **Use exact JustDial category names** — copy the slug from a JustDial URL (e.g. `/Mumbai/IT-Companies`) for precise matching
- **Start with small limits** — use `maxResultsPerSearch: 20` to test your search, then scale up
- **Target Tier 2 cities** — JustDial's coverage of Nashik, Surat, Indore is much better than Google Maps for local businesses
- **Filter by rating** — post-process results to keep only businesses with `rating >= 4.0` for higher-quality outreach
- **Multi-city campaigns** — add 5–10 city+category pairs in a single run for bulk lead collection

### 🔗 Integrations

**CRM upload via Zapier / Make:**
Export the dataset as CSV from Apify and import directly into Salesforce, HubSpot, Pipedrive, or Zoho CRM for immediate outreach.

**Google Sheets sync:**
Use the [Apify Google Sheets integration](https://apify.com/apify/google-sheets-import-export) to sync the dataset directly to a sheet your sales team uses.

**Automated email outreach:**
Pipe leads into Instantly.ai, Apollo.io, or Lemlist via CSV to run targeted email sequences by category and city.

**Webhook-triggered enrichment:**
Trigger enrichment workflows on each new batch using Apify webhooks → n8n → LinkedIn enrichment → CRM push.

### 🔌 API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/justdial-leads-scraper').call({
    searches: [
        { city: 'Mumbai', category: 'Restaurants' },
        { city: 'Delhi', category: 'Dentists' },
    ],
    maxResultsPerSearch: 100,
    includePhoneNumbers: true,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/justdial-leads-scraper").call(run_input={
    "searches": [
        {"city": "Bangalore", "category": "IT-Companies"},
        {"city": "Chennai", "category": "Hospitals"},
    ],
    "maxResultsPerSearch": 200,
    "includePhoneNumbers": True,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Extracted {len(items)} leads")
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~justdial-leads-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searches": [{"city": "Pune", "category": "Gyms"}],
    "maxResultsPerSearch": 50
  }'
```

### 🤖 MCP (Claude AI) integration

Connect this actor to Claude AI via the Model Context Protocol (MCP) for conversational lead scraping.

#### Claude Code / terminal

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/justdial-leads-scraper"
```

#### Claude Desktop / Cursor / VS Code

Add to your MCP config (`claude_desktop_config.json` or `settings.json`):

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/justdial-leads-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

#### Example prompts

- *"Scrape the top 50 restaurants in Hyderabad from JustDial"*
- *"Get me a list of IT companies in Bangalore with rating above 4.0"*
- *"Extract dentists in Delhi and Chennai for our dental supply outreach campaign"*
- *"Find 200 gyms across Mumbai, Pune, and Nashik with their phone numbers"*

### ⚖️ Legality

This actor scrapes publicly available data from JustDial. Business names, addresses, phone numbers, and ratings displayed on JustDial's public search result pages are intended for public discovery of local services. Web scraping of public data is generally lawful under Indian and international law when done for legitimate commercial purposes.

We recommend:

- Respecting rate limits (the actor uses conservative concurrency settings by default)
- Using the data for legitimate B2B outreach, research, or internal use
- Not reselling raw scraped data without adding value
- Complying with applicable data protection regulations (PDPB/IT Act in India, GDPR if handling EU data)

### ❓ FAQ

**Q: How many results can I get per search?**
A: JustDial typically shows 10 results per page. The actor paginates automatically. Practical limits vary by city and category — major metros often have 50–200+ results for popular categories, while niche categories may have 10–30.

**Q: Why is a residential proxy required?**
A: JustDial uses Akamai bot protection that blocks datacenter IP addresses. Indian residential proxy IPs are required. The actor defaults to Apify's RESIDENTIAL proxy group with `countryCode=IN`. This is included in the PPE pricing.

**Q: Phone numbers appear as partial — why?**
A: JustDial occasionally masks phone numbers in search results for privacy reasons. In most cases, the full number is visible in the HTML source. If you see partial numbers, try the listing URL directly.

**Q: Can I scrape a specific locality or area?**
A: Currently the actor targets city + category. For more specific area targeting, pass the full JustDial search URL (e.g. `https://www.justdial.com/Mumbai/Restaurants-in-Bandra`) in the `urls` parameter.

**Q: The actor returned 0 results — what happened?**
A: Most likely the residential proxy IP was rate-limited by JustDial. Try running again (the actor rotates IPs on each run). If issues persist, contact support.

**Q: Can I scrape reviews or detailed listing pages?**
A: This actor focuses on search result pages (high-volume lead lists). For review scraping or detailed listing pages, see [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews).

### 🔗 Related scrapers

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — global business leads with coordinates
- [Naukri Job Scraper](https://apify.com/automation-lab/naukri-scraper) — Indian job listings for talent sourcing
- [Yellow Pages Scraper](https://apify.com/automation-lab/yellowpages-scraper) — US/Canada business leads
- [PagesJaunes France Business Scraper](https://apify.com/automation-lab/pagesjaunes-france-business-scraper) — French business directory

# Actor input Schema

## `searches` (type: `array`):

List of city + category pairs to search. Example: \[{"city": "Mumbai", "category": "Restaurants"}]. Use Indian city names (Mumbai, Delhi, Bangalore, Chennai, Hyderabad, Pune, Kolkata).

## `urls` (type: `array`):

Optional: paste direct JustDial search page URLs instead of city+category pairs. Example: \["https://www.justdial.com/Mumbai/Restaurants"].

## `maxResultsPerSearch` (type: `integer`):

Maximum number of business leads to extract per city+category search. Each result is charged separately.

## `includePhoneNumbers` (type: `boolean`):

Extract phone numbers from listings. JustDial shows phone numbers on search results pages.

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

Number of pages to process in parallel. Keep low (1-3) for JustDial to avoid rate limiting.

## `maxRetries` (type: `integer`):

Number of retry attempts for failed requests before skipping.

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

Proxy settings. JustDial requires Indian residential proxy to bypass Akamai protection. Defaults to RESIDENTIAL group with IN country — do not change unless you know what you're doing.

## Actor input object example

```json
{
  "searches": [
    {
      "city": "Mumbai",
      "category": "Restaurants"
    }
  ],
  "maxResultsPerSearch": 20,
  "includePhoneNumbers": true,
  "maxConcurrency": 2,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searches": [
        {
            "city": "Mumbai",
            "category": "Restaurants"
        }
    ],
    "maxResultsPerSearch": 20,
    "includePhoneNumbers": true,
    "maxConcurrency": 2,
    "maxRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/justdial-leads-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 = {
    "searches": [{
            "city": "Mumbai",
            "category": "Restaurants",
        }],
    "maxResultsPerSearch": 20,
    "includePhoneNumbers": True,
    "maxConcurrency": 2,
    "maxRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/justdial-leads-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searches": [
    {
      "city": "Mumbai",
      "category": "Restaurants"
    }
  ],
  "maxResultsPerSearch": 20,
  "includePhoneNumbers": true,
  "maxConcurrency": 2,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call automation-lab/justdial-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JustDial Business Leads Scraper",
        "description": "Extract business leads from JustDial — India's largest local directory with 30M+ listings. Get name, phone, address, rating, and reviews for B2B prospecting.",
        "version": "0.1",
        "x-build-id": "YDPc8WPedNFv6TUH5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~justdial-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-justdial-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~justdial-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-justdial-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~justdial-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-justdial-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searches": {
                        "title": "🏙️ City + category searches",
                        "type": "array",
                        "description": "List of city + category pairs to search. Example: [{\"city\": \"Mumbai\", \"category\": \"Restaurants\"}]. Use Indian city names (Mumbai, Delhi, Bangalore, Chennai, Hyderabad, Pune, Kolkata)."
                    },
                    "urls": {
                        "title": "📎 Direct JustDial search URLs",
                        "type": "array",
                        "description": "Optional: paste direct JustDial search page URLs instead of city+category pairs. Example: [\"https://www.justdial.com/Mumbai/Restaurants\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of business leads to extract per city+category search. Each result is charged separately.",
                        "default": 100
                    },
                    "includePhoneNumbers": {
                        "title": "Include phone numbers",
                        "type": "boolean",
                        "description": "Extract phone numbers from listings. JustDial shows phone numbers on search results pages.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent pages",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of pages to process in parallel. Keep low (1-3) for JustDial to avoid rate limiting.",
                        "default": 2
                    },
                    "maxRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed requests before skipping.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. JustDial requires Indian residential proxy to bypass Akamai protection. Defaults to RESIDENTIAL group with IN country — do not change unless you know what you're doing.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
