# AskLaila India Business Directory Scraper (`crawlerbros/asklaila-india-business-directory-scraper`) Actor

Scrape AskLaila Indian business listings across 45+ cities. Extract names, addresses, phone numbers, ratings, reviews, geo coordinates, photos, payment options, and category attributes from restaurants, doctors, hotels, gyms, schools, plumbers and more.

- **URL**: https://apify.com/crawlerbros/asklaila-india-business-directory-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 17 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## AskLaila India Business Directory Scraper

Scrape AskLaila — one of India's longest-running local business directories — to extract structured records for restaurants, doctors, hotels, gyms, schools, plumbers, electricians, salons, supermarkets, and dozens more categories across 45+ Indian cities.

The actor pulls every datum AskLaila publicly exposes via Schema.org microdata: business name, multi-line postal address, multiple phone numbers, geo coordinates, ratings, review counts, recommendation percentage, services & amenities, cuisine, payment options, photos, and review snippets.

### Why this actor

- **No login, no API keys, no cookies.** AskLaila is a public directory; everything is server-side rendered.
- **No proxy required from datacenter IPs.** Use the optional Apify proxy only if you hit blocks.
- **Rich Schema.org microdata.** Listings expose `LocalBusiness` / `Restaurant` itemtypes with addresses, geo, aggregate ratings, cuisine, payment, and reviews — the actor maps every field.
- **45+ Indian cities, 50+ pre-curated categories.** Pick any city + category from a dropdown — no URL crafting required.
- **Locality drill-down.** Narrow searches to a specific neighborhood (e.g. `Koramangala` in Bangalore, `Andheri` in Mumbai).
- **Free-text keyword search.** Find a chain by name (`Apollo Hospital`, `Domino's`) inside a city.

### Modes

| Mode | When to use it | Required inputs |
|------|----------------|-----------------|
| `byCategory` (default) | Pick a city + category from dropdowns | `city`, `category` (`locality` optional) |
| `searchUrls` | Paste AskLaila search/category URLs you already have | `searchUrls` |
| `listingUrls` | Enrich a known list of business detail page URLs | `listingUrls` |
| `keywordSearch` | Free-text search inside a city | `city`, `keyword` |

### Output (per-business record)

Each dataset row represents a single business. Fields are emitted only when AskLaila publishes them — there are no null/empty values in your dataset.

- `name` — business name (e.g. `Hallimane`)
- `category` — primary category (e.g. `Restaurant`, `Dentist`, `Plumber`)
- `businessType` — Schema.org type (`Restaurant`, `LocalBusiness`, `Hospital`, ...)
- `breadcrumbs` — site breadcrumb trail from city → category → business
- `phoneNumbers` — array of digits-only phone numbers (multiple per business is common)
- `streetAddress`, `locality`, `city`, `postalCode`, `fullAddress`, `landmark`
- `latitude`, `longitude` — Schema.org GeoCoordinates
- `ratingValue`, `ratingCount`, `reviewCount`, `recommendPercent`
- `cuisine` (restaurants), `paymentAccepted`, `attributes` (a key/value map of category-specific facts: `Catering`, `Home Delivery`, `Veg/Non-Veg`, `AC`, `Valet Parking`, `Credit Cards Accepted`, `Alcohol`, `Working Hours`, ...)
- `photos` — array of photo URLs
- `reviews` — array of `{authorName, ratingValue, datePublished, reviewBody}`
- `listingUrl`, `canonicalUrl`, `listingId`, `sourceUrl`
- `recordType`, `scrapedAt`, `siteName`

### Filters

- `minRating` — drop businesses below an integer rating threshold (1-5).
- `minReviewCount` — drop businesses with too few reviews.
- `fetchListingDetails` — disable to emit only card-level fields (faster, lighter).
- `includeReviews` — disable to skip review extraction on detail pages.
- `maxItems` — hard cap on the total emitted records (1-1000).

### Proxy / runtime inputs

- `useProxy` — route requests through Apify proxy. Off by default; AskLaila is reachable from datacenter IPs.
- `autoEscalateOnBlock` — if a fetch is empty or blocked, retry once with a residential proxy session.
- `proxyConfiguration` — advanced Apify proxy configuration object; only used when `useProxy=true`.

### Coverage

The dropdowns expose 45+ major Indian cities and 50+ business categories. Beyond the dropdowns, paste any AskLaila URL into `searchUrls` or `listingUrls` and the actor will scrape it — coverage is effectively the entire AskLaila corpus.

### Frequently asked questions

**Does this need an account, cookies, or login?** No. AskLaila is fully public.

**Will I get blocked?** Unlikely. AskLaila is normally reachable from datacenter IPs without throttling. Set `useProxy=true` if you see empty pages on your runs; `autoEscalateOnBlock` will automatically retry once with a residential session.

**Can I get phone numbers?** Yes. AskLaila publishes multiple phone numbers per business (`phoneNumbers` array). They are returned as digits-only strings, ready for downstream cleansing.

**Can I get business reviews?** Yes — set `includeReviews=true` (the default) and ensure `fetchListingDetails=true`. Reviews include the reviewer name, star rating, date, and review body.

**Can I get geo coordinates?** Yes — when AskLaila has them on the listing detail page (most listings do), `latitude` and `longitude` are emitted as floats.

**Does it support pagination?** Yes — the actor automatically follows AskLaila's 20-per-page pagination until `maxItems` is reached or the listings are exhausted.

**Is locality filtering supported?** Yes — the optional `locality` input restricts a `byCategory` search to a specific neighborhood inside the chosen city.

**Are reviews paginated?** Visible reviews on the detail page (typically the last 5-20) are extracted. AskLaila does not expose a paginated review API.

### Example: top restaurants in Bangalore (Koramangala)

```json
{
  "mode": "byCategory",
  "city": "Bangalore",
  "category": "restaurants",
  "locality": "Koramangala",
  "fetchListingDetails": true,
  "includeReviews": true,
  "minRating": 4,
  "maxItems": 50
}
````

### Example: keyword search

```json
{
  "mode": "keywordSearch",
  "city": "Mumbai",
  "keyword": "Apollo Hospital",
  "maxItems": 25
}
```

### Example: enrich a list of profiles

```json
{
  "mode": "listingUrls",
  "listingUrls": [
    "https://www.asklaila.com/listing/Bangalore/malleswaram/hallimane/1OjwP4uM/"
  ],
  "includeReviews": true
}
```

# Actor input Schema

## `mode` (type: `string`):

How to seed the crawl. `byCategory` builds a search URL from city + category dropdowns. `searchUrls` accepts AskLaila search/category URLs directly. `listingUrls` fetches individual business detail pages. `keywordSearch` performs a free-text search inside a city.

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

Indian city as recognized by AskLaila. Used for `byCategory` and `keywordSearch` modes. Pick from the dropdown of all major covered cities.

## `category` (type: `string`):

Business category slug. Used for `byCategory` mode. AskLaila supports hundreds of categories — the dropdown lists the most popular axes.

## `locality` (type: `string`):

Optional locality / neighborhood inside the city to narrow the search (e.g. `Koramangala`, `Andheri`, `Connaught-Place`). Leave blank to search city-wide. Only used with `byCategory` mode.

## `keyword` (type: `string`):

Free-text business search inside the selected city. Used by the `keywordSearch` mode (e.g. `Domino's pizza`, `Apollo hospital`).

## `searchUrls` (type: `array`):

AskLaila search or category URLs to scrape directly. Examples: `https://www.asklaila.com/search/Bangalore/-/restaurants/`, `https://www.asklaila.com/search/Mumbai/Andheri/dentists/`. Used by `searchUrls` mode.

## `listingUrls` (type: `array`):

AskLaila business listing detail page URLs. Example: `https://www.asklaila.com/listing/Bangalore/malleswaram/hallimane/1OjwP4uM/`. Used by `listingUrls` mode.

## `fetchListingDetails` (type: `boolean`):

When enabled, each search/category card is enriched with a follow-up GET to the listing detail page, adding street address, postal code, geo coordinates, working hours, services attributes, photos, and review snippets. Disable for faster, lighter runs that emit only card-level fields.

## `includeReviews` (type: `boolean`):

When `fetchListingDetails` is enabled, also extract the visible reviewer name, star rating, date, and review body for each review on the listing detail page.

## `minRating` (type: `integer`):

Filter out businesses whose rating is below this threshold (1-5). Set to 0 to disable.

## `minReviewCount` (type: `integer`):

Filter out businesses with fewer than this many user reviews on AskLaila. Set to 0 to disable.

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

Hard cap on the number of business records emitted to the dataset.

## `useProxy` (type: `boolean`):

Route requests through Apify proxy. AskLaila is normally reachable from datacenter IPs without a proxy. Enable only if cloud runs return empty pages.

## `autoEscalateOnBlock` (type: `boolean`):

If a fetch is empty or blocked, retry once with a residential Apify proxy session as a safety net. Card-level data is still emitted as fallback when detail fetches fail.

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

Optional Apify proxy configuration. Only used when `useProxy` is enabled. Leave empty to let `useProxy` + `autoEscalateOnBlock` pick sane defaults.

## Actor input object example

```json
{
  "mode": "byCategory",
  "city": "Bangalore",
  "category": "restaurants",
  "locality": "",
  "keyword": "",
  "searchUrls": [],
  "listingUrls": [],
  "fetchListingDetails": true,
  "includeReviews": true,
  "minRating": 0,
  "minReviewCount": 0,
  "maxItems": 25,
  "useProxy": false,
  "autoEscalateOnBlock": true,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing AskLaila business records.

# 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 = {
    "mode": "byCategory",
    "city": "Bangalore",
    "category": "restaurants",
    "locality": "",
    "keyword": "",
    "searchUrls": [],
    "listingUrls": [],
    "fetchListingDetails": true,
    "includeReviews": true,
    "minRating": 0,
    "minReviewCount": 0,
    "maxItems": 25,
    "useProxy": false,
    "autoEscalateOnBlock": true,
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/asklaila-india-business-directory-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 = {
    "mode": "byCategory",
    "city": "Bangalore",
    "category": "restaurants",
    "locality": "",
    "keyword": "",
    "searchUrls": [],
    "listingUrls": [],
    "fetchListingDetails": True,
    "includeReviews": True,
    "minRating": 0,
    "minReviewCount": 0,
    "maxItems": 25,
    "useProxy": False,
    "autoEscalateOnBlock": True,
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/asklaila-india-business-directory-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 '{
  "mode": "byCategory",
  "city": "Bangalore",
  "category": "restaurants",
  "locality": "",
  "keyword": "",
  "searchUrls": [],
  "listingUrls": [],
  "fetchListingDetails": true,
  "includeReviews": true,
  "minRating": 0,
  "minReviewCount": 0,
  "maxItems": 25,
  "useProxy": false,
  "autoEscalateOnBlock": true,
  "proxyConfiguration": {}
}' |
apify call crawlerbros/asklaila-india-business-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/asklaila-india-business-directory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AskLaila India Business Directory Scraper",
        "description": "Scrape AskLaila Indian business listings across 45+ cities. Extract names, addresses, phone numbers, ratings, reviews, geo coordinates, photos, payment options, and category attributes from restaurants, doctors, hotels, gyms, schools, plumbers and more.",
        "version": "1.0",
        "x-build-id": "X6vK4e2qJfkurSteV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~asklaila-india-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-asklaila-india-business-directory-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/crawlerbros~asklaila-india-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-asklaila-india-business-directory-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/crawlerbros~asklaila-india-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-asklaila-india-business-directory-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCategory",
                            "searchUrls",
                            "listingUrls",
                            "keywordSearch"
                        ],
                        "type": "string",
                        "description": "How to seed the crawl. `byCategory` builds a search URL from city + category dropdowns. `searchUrls` accepts AskLaila search/category URLs directly. `listingUrls` fetches individual business detail pages. `keywordSearch` performs a free-text search inside a city.",
                        "default": "byCategory"
                    },
                    "city": {
                        "title": "City",
                        "enum": [
                            "Bangalore",
                            "Mumbai",
                            "Delhi",
                            "Chennai",
                            "Hyderabad",
                            "Pune",
                            "Kolkata",
                            "Ahmedabad",
                            "Jaipur",
                            "Lucknow",
                            "Surat",
                            "Kanpur",
                            "Nagpur",
                            "Indore",
                            "Bhopal",
                            "Patna",
                            "Vadodara",
                            "Ludhiana",
                            "Agra",
                            "Nashik",
                            "Faridabad",
                            "Meerut",
                            "Rajkot",
                            "Varanasi",
                            "Amritsar",
                            "Allahabad",
                            "Coimbatore",
                            "Vijayawada",
                            "Visakhapatnam",
                            "Madurai",
                            "Gurgaon",
                            "Noida",
                            "Ghaziabad",
                            "Thane",
                            "Howrah",
                            "Mysore",
                            "Mangalore",
                            "Trivandrum",
                            "Kochi",
                            "Chandigarh",
                            "Goa",
                            "Guwahati",
                            "Bhubaneswar",
                            "Dehradun",
                            "Jodhpur",
                            "Raipur"
                        ],
                        "type": "string",
                        "description": "Indian city as recognized by AskLaila. Used for `byCategory` and `keywordSearch` modes. Pick from the dropdown of all major covered cities.",
                        "default": "Bangalore"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "restaurants",
                            "hotels",
                            "doctors",
                            "dentists",
                            "hospitals",
                            "clinics",
                            "pharmacies",
                            "diagnostic-centres",
                            "gyms",
                            "yoga-classes",
                            "salons",
                            "beauty-parlours",
                            "spas",
                            "schools",
                            "colleges",
                            "coaching-classes",
                            "play-schools",
                            "plumbers",
                            "electricians",
                            "carpenters",
                            "painters",
                            "interior-designers",
                            "architects",
                            "real-estate-agents",
                            "lawyers",
                            "chartered-accountants",
                            "tax-consultants",
                            "banks",
                            "atms",
                            "courier-services",
                            "movers-and-packers",
                            "car-dealers",
                            "car-rentals",
                            "travel-agents",
                            "tour-operators",
                            "supermarkets",
                            "departmental-stores",
                            "jewellers",
                            "boutiques",
                            "tailors",
                            "florists",
                            "bakeries",
                            "sweet-shops",
                            "computer-repair",
                            "mobile-phone-repair",
                            "ac-repair",
                            "pest-control",
                            "veterinarians",
                            "pet-shops",
                            "photographers",
                            "event-organisers",
                            "caterers",
                            "wedding-halls",
                            "petrol-pumps",
                            "auto-repair"
                        ],
                        "type": "string",
                        "description": "Business category slug. Used for `byCategory` mode. AskLaila supports hundreds of categories — the dropdown lists the most popular axes.",
                        "default": "restaurants"
                    },
                    "locality": {
                        "title": "Locality (optional)",
                        "type": "string",
                        "description": "Optional locality / neighborhood inside the city to narrow the search (e.g. `Koramangala`, `Andheri`, `Connaught-Place`). Leave blank to search city-wide. Only used with `byCategory` mode.",
                        "default": ""
                    },
                    "keyword": {
                        "title": "Keyword (free-text search)",
                        "type": "string",
                        "description": "Free-text business search inside the selected city. Used by the `keywordSearch` mode (e.g. `Domino's pizza`, `Apollo hospital`).",
                        "default": ""
                    },
                    "searchUrls": {
                        "title": "Search / category URLs",
                        "type": "array",
                        "description": "AskLaila search or category URLs to scrape directly. Examples: `https://www.asklaila.com/search/Bangalore/-/restaurants/`, `https://www.asklaila.com/search/Mumbai/Andheri/dentists/`. Used by `searchUrls` mode.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "Listing detail URLs",
                        "type": "array",
                        "description": "AskLaila business listing detail page URLs. Example: `https://www.asklaila.com/listing/Bangalore/malleswaram/hallimane/1OjwP4uM/`. Used by `listingUrls` mode.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchListingDetails": {
                        "title": "Fetch listing detail pages (richer data)",
                        "type": "boolean",
                        "description": "When enabled, each search/category card is enriched with a follow-up GET to the listing detail page, adding street address, postal code, geo coordinates, working hours, services attributes, photos, and review snippets. Disable for faster, lighter runs that emit only card-level fields.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include user reviews on detail pages",
                        "type": "boolean",
                        "description": "When `fetchListingDetails` is enabled, also extract the visible reviewer name, star rating, date, and review body for each review on the listing detail page.",
                        "default": true
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Filter out businesses whose rating is below this threshold (1-5). Set to 0 to disable.",
                        "default": 0
                    },
                    "minReviewCount": {
                        "title": "Minimum review count",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Filter out businesses with fewer than this many user reviews on AskLaila. Set to 0 to disable.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of business records emitted to the dataset.",
                        "default": 25
                    },
                    "useProxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify proxy. AskLaila is normally reachable from datacenter IPs without a proxy. Enable only if cloud runs return empty pages.",
                        "default": false
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate on block",
                        "type": "boolean",
                        "description": "If a fetch is empty or blocked, retry once with a residential Apify proxy session as a safety net. Card-level data is still emitted as fallback when detail fetches fail.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration (advanced)",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Only used when `useProxy` is enabled. Leave empty to let `useProxy` + `autoEscalateOnBlock` pick sane defaults.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
