# Local Lead Intelligence (`abrahan_dev/local-lead-intelligence`) Actor

Discover, enrich, deduplicate, and rank public local-business leads.

- **URL**: https://apify.com/abrahan\_dev/local-lead-intelligence.md
- **Developed by:** [Abrahan Gil](https://apify.com/abrahan_dev) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 scored leads

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

![Local Lead Intelligence - find, enrich, and score local business leads at scale](https://i.ibb.co/P7PfxzB/banner.png)

Turn Google Maps searches into **enriched, deduplicated, and prioritized local business leads**.

Local Lead Intelligence finds businesses for any niche and location, visits their public websites, extracts contact and digital signals, and assigns every lead an explainable opportunity score. Use it to build prospect lists that are ready for sales research instead of spending hours cleaning raw Google Maps results.

- Find local businesses by **search query and location**
- Extract phones, websites, ratings, reviews, coordinates, and Google Maps URLs
- Discover public emails, social profiles, contact forms, WhatsApp, and booking tools
- Detect CMS, analytics, advertising pixels, and structured data
- Remove duplicates across overlapping searches
- Prioritize prospects with a transparent `0-100` lead score and sales angle
- Export results to JSON, CSV, Excel, XML, or HTML, or access them through the Apify API

### What does Local Lead Intelligence do?

Local Lead Intelligence is a [Google Maps](https://www.google.com/maps) lead scraper, lead generation API, and website enrichment Actor. It combines browser-based Google Maps discovery with fast website crawling to produce a single clean dataset of sales-ready business records.

For every discovered business, the Actor can:

1. Open its Google Maps listing and collect the available business details.
2. Normalize domains, phones, names, addresses, and coordinates.
3. Remove duplicate businesses before spending time on enrichment.
4. Visit the public business website and relevant contact, about, booking, and legal pages.
5. Identify contact channels and digital technologies.
6. Calculate an explainable lead score, tier, confidence, reasons, and suggested sales angle.

The result is not just a directory of businesses. It is a prioritized lead list designed to help you decide **who to contact first and why**.

### Why use Local Lead Intelligence?

#### Build targeted prospect lists

Find businesses in specific industries, cities, regions, or countries. Combine up to 20 queries and 20 locations in one run, with a maximum of 100 search combinations.

#### Prioritize outreach

Use lead tiers, score reasons, and sales angles to focus research and outreach on the most promising opportunities instead of treating every Maps result equally.

#### Research local markets

Compare business density, online reputation, contactability, and digital maturity across niches or locations.

#### Find digital-service opportunities

Identify businesses with missing contact options, limited social presence, no booking system, weak tracking setup, or other public website signals relevant to agencies and consultants.

#### Automate repeatable workflows

Run the Actor manually, through the Apify API, on a schedule, or as part of a workflow using webhooks and Apify integrations.

### What data can it extract?

| Category | Available fields |
| --- | --- |
| Business identity | Name, category, deterministic business ID, Google Place ID |
| Location | Address, latitude, longitude, requested location |
| Contact details | Phone, website, public email addresses |
| Google Maps signals | Rating, review count, listing URL, source query |
| Social profiles | Public business profile links found on the website |
| Conversion signals | Contact forms, WhatsApp links, booking systems |
| Website technology | CMS, analytics, advertising pixels, structured data |
| Lead intelligence | Lead score, tier, confidence, score breakdown, reasons, sales angle |
| Run metadata | Enrichment status and scrape timestamp |

Website and contact fields depend on what each business publishes publicly. The Actor returns `null`, an empty array, or a partial enrichment status when information is unavailable.

### How to generate local business leads

1. Open the Actor and enter one or more business queries, such as `dentists`, `solar installers`, or `real estate agencies`.
2. Add the cities, regions, or countries you want to search.
3. Choose how many results to request for each query and location.
4. Keep website enrichment and lead scoring enabled for sales-ready output, or disable them for basic Maps data.
5. Click **Start** and open the **Dataset** tab when the run finishes.
6. Filter by score or tier, then download the results or access them through the API.

### Input

The simplest run only needs `queries` and `locations`. See the Actor's **Input** tab for every configuration option.

```json
{
  "queries": ["dentists", "solar installers"],
  "locations": ["Madrid, Spain", "Lisbon, Portugal"],
  "maxResultsPerQuery": 100,
  "language": "en",
  "enrichWebsite": true,
  "findEmails": true,
  "findSocialProfiles": true,
  "detectTechnologies": true,
  "scoreLeads": true,
  "dedupeMode": "strict"
}
````

#### Main input options

| Field | Description | Default |
| --- | --- | --- |
| `queries` | Business categories or search phrases. Required, up to 20. | - |
| `locations` | Cities, regions, or countries. Required, up to 20. | - |
| `maxResultsPerQuery` | Maximum requested results for each query and location. | `100` |
| `language` | ISO language code used by Google Maps. | `en` |
| `countryCode` | Optional ISO two-letter country code for phone normalization. | - |
| `enrichWebsite` | Visit public business websites for additional signals. | `true` |
| `findEmails` | Extract publicly visible email addresses. | `true` |
| `findSocialProfiles` | Extract public social profile links. | `true` |
| `detectTechnologies` | Detect website, tracking, form, and booking technologies. | `true` |
| `scoreLeads` | Calculate explainable scores and sales angles. | `true` |
| `dedupeMode` | Use `strict` or `loose` duplicate detection. | `strict` |
| `excludedDomains` | Domains that must not be enriched or returned. | `[]` |
| `excludedPlaceIds` | Google Place IDs that must not be returned. | `[]` |

A run supports up to **100 query-location combinations** and **10,000 requested results**. Google Maps may return fewer businesses than requested.

#### Deduplication modes

- `strict` matches businesses by Google Place ID, website domain, or phone number.
- `loose` also compares normalized names, addresses, and nearby coordinates.

Use `strict` when you want conservative matching. Use `loose` when overlapping searches produce many variations of the same business.

### Output

Results are stored in the default Apify dataset. You can view them as a table, access them through the API, or download them as JSON, CSV, Excel, XML, or HTML.

```json
{
  "business_id": "place_9d30b38e...",
  "place_id": "ChIJ...",
  "source": "google_maps",
  "query": "dentists",
  "location": "Madrid, Spain",
  "name": "Example Dental Clinic",
  "category": "Dentist",
  "address": "Calle Example 10, Madrid",
  "phone": "+34910000000",
  "website": "https://example-dental.es/",
  "google_maps_url": "https://www.google.com/maps/place/...",
  "rating": 4.6,
  "review_count": 128,
  "latitude": 40.4168,
  "longitude": -3.7038,
  "emails": ["info@example-dental.es"],
  "social_profiles": {
    "instagram": "https://www.instagram.com/exampledental",
    "facebook": null,
    "linkedin": null,
    "youtube": null,
    "x": null
  },
  "website_signals": {
    "has_contact_page": true,
    "has_about_page": true,
    "has_booking": false,
    "has_whatsapp": true,
    "has_contact_form": true,
    "has_meta_pixel": false,
    "has_google_analytics": true,
    "has_schema_org": true,
    "cms": "wordpress",
    "page_speed_hint": "medium",
    "pages_crawled": 4
  },
  "lead_score": 78,
  "lead_tier": "GOLD",
  "sales_angle": "Improve online booking and conversion tracking.",
  "confidence": 0.86,
  "score_breakdown": {
    "fit": 80,
    "contactability": 95,
    "opportunity": 70,
    "reputation": 82,
    "freshness": 50
  },
  "score_reasons": [
    "Public phone, website, and email are available",
    "Strong reputation based on rating and review volume",
    "No booking system detected"
  ],
  "enrichment_status": "complete",
  "scraped_at": "2026-06-09T12:00:00.000Z"
}
```

Recoverable discovery and website errors are stored separately in the named `errors` dataset, so one blocked or unavailable website does not cancel the whole run.

### Explainable lead scoring

When scoring is enabled, every lead receives a deterministic score based on:

```text
25% fit + 25% contactability + 20% opportunity
+ 15% reputation + 15% freshness
```

| Tier | Score |
| --- | --- |
| `PLATINUM` | 85-100 |
| `GOLD` | 70-84 |
| `SILVER` | 50-69 |
| `BRONZE` | 0-49 |

The Actor does not use an LLM to invent recommendations. Scores are generated from collected signals and accompanied by `score_breakdown` and `score_reasons`. Because the current version does not retain cross-run history, freshness is neutral and confidence is adjusted accordingly.

### How much does it cost?

Local Lead Intelligence uses **pay-per-event pricing**. The Actor selects one exclusive product event for each stored lead:

| Event | Result |
| --- | --- |
| `lead_basic` | Google Maps lead without website enrichment or scoring |
| `lead_enriched` | Lead with website enrichment and no scoring |
| `lead_scored` | Lead with explainable scoring enabled |

Check the Actor's **Pricing** tab for the current price of each result type. Cost depends on the number of unique leads stored and the enabled processing level. Duplicate, excluded, and failed records are not stored as lead results.

The Actor stops saving additional leads if the run spending limit is reached.

### API, schedules, and integrations

Local Lead Intelligence can be used as a local lead generation API. Open the Actor's **API** tab to find ready-to-use examples for JavaScript, Python, and direct HTTP requests.

You can also:

- Schedule recurring searches to refresh prospect lists
- Trigger follow-up workflows with webhooks
- Send datasets to spreadsheets, databases, automation tools, or your own application
- Monitor runs and retrieve output programmatically through the Apify API

### Performance and result quality

The Actor uses Playwright for JavaScript-heavy Google Maps discovery and HTTP-first website crawling for faster enrichment. It processes searches and websites concurrently while keeping complete business detail extraction enabled.

For larger enriched runs:

- Use distinct queries with minimal overlap to reduce duplicate discovery work.
- Split independent locations across several Actor runs when minimum latency matters.
- Assign at least 4 GB of memory when using high concurrency.
- Reduce concurrency if the run approaches its memory limit or encounters frequent blocking.
- Lower `maxEnrichmentPages` when only homepage signals are needed.

Complete records require opening individual Google Maps listings. Higher speed should not come at the cost of missing phones, websites, addresses, ratings, or other core lead fields.

### Limitations

- Google Maps can return fewer results than requested and may vary results by location, language, and time.
- Google Maps interface changes may temporarily affect extraction until the parser is updated.
- Some websites block automated requests, are unavailable, or require JavaScript, resulting in partial or failed enrichment.
- Public email addresses and social profiles are not available for every business.
- The Actor does not validate email inboxes, collect historical changes, send campaigns, or write directly to a CRM.

### Frequently asked questions

#### Can it find email addresses?

Yes. When website enrichment and email extraction are enabled, the Actor searches the business's public website and relevant pages for visibly published email addresses. Results depend on what the business makes available.

#### Does it support any country or niche?

The Actor accepts general Google Maps queries and locations worldwide. Use `countryCode` to improve international phone normalization and set the appropriate `language` for the target market.

#### Why did I receive fewer leads than requested?

Google Maps may expose fewer matching listings than the requested maximum. Deduplication and exclusion lists can further reduce the final number of unique leads.

#### Can I export the leads to my CRM?

You can download the dataset or retrieve it through the Apify API, then import it into your CRM. You can also use Apify webhooks and integrations to automate delivery.

#### How are lead scores calculated?

Scores are rule-based and use observable business, contact, website, reputation, and freshness signals. Inspect `score_breakdown` and `score_reasons` to understand each result.

### Responsible use

This Actor collects information that businesses make publicly visible on Google Maps and their public websites. It does not bypass authentication or collect private data.

You are responsible for using the results in accordance with applicable laws, privacy requirements, marketing rules, opt-out obligations, and the terms of the websites and services you use. If your use case involves personal data or regulated outreach, consult qualified legal counsel.

### Support

Found a bug, a missing field, or a business website that was not enriched correctly? Open an issue in the Actor's **Issues** tab and include the run ID, a small reproducible input, and the expected result. Feature requests and feedback are welcome.

# Actor input Schema

## `queries` (type: `array`):

Business categories or search phrases. Use distinct queries to reduce duplicates.

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

Cities, regions, or countries included in each Maps search.

## `maxResultsPerQuery` (type: `integer`):

Google Maps may return fewer results than requested.

## `language` (type: `string`):

ISO language code used by Google Maps.

## `countryCode` (type: `string`):

Optional ISO 3166-1 alpha-2 code used for phone normalization.

## `enrichWebsite` (type: `boolean`):

Visit public website pages to identify contact and commercial signals.

## `findEmails` (type: `boolean`):

Extract email addresses visibly published on the business website.

## `findSocialProfiles` (type: `boolean`):

Extract links to public business profiles on supported social networks.

## `detectTechnologies` (type: `boolean`):

Detect CMS, analytics, pixels, forms, booking tools, WhatsApp, and schema signals.

## `scoreLeads` (type: `boolean`):

Calculate explainable opportunity scores and sales angles.

## `dedupeMode` (type: `string`):

Loose mode also compares normalized names, addresses, and nearby coordinates.

## `excludedDomains` (type: `array`):

Domains that must not be enriched or returned.

## `excludedPlaceIds` (type: `array`):

Google Place IDs that must not be returned.

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

Apify Proxy or custom proxy configuration used by the Google Maps collector.

## `discoveryConcurrency` (type: `integer`):

Maximum number of Google Maps pages processed in parallel. Higher values need more memory and may increase blocking.

## `enrichmentConcurrency` (type: `integer`):

Maximum number of public business website pages processed in parallel.

## `maxEnrichmentPages` (type: `integer`):

Maximum number of pages visited per business website, including its home page.

## Actor input object example

```json
{
  "queries": [
    "dentists"
  ],
  "locations": [
    "Madrid, Spain"
  ],
  "maxResultsPerQuery": 100,
  "language": "en",
  "enrichWebsite": true,
  "findEmails": true,
  "findSocialProfiles": true,
  "detectTechnologies": true,
  "scoreLeads": true,
  "dedupeMode": "strict",
  "excludedDomains": [],
  "excludedPlaceIds": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "discoveryConcurrency": 20,
  "enrichmentConcurrency": 50,
  "maxEnrichmentPages": 4
}
```

# Actor output Schema

## `leads` (type: `string`):

No description

## `errors` (type: `string`):

No description

## `summary` (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 = {
    "queries": [
        "dentists"
    ],
    "locations": [
        "Madrid, Spain"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("abrahan_dev/local-lead-intelligence").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 = {
    "queries": ["dentists"],
    "locations": ["Madrid, Spain"],
}

# Run the Actor and wait for it to finish
run = client.actor("abrahan_dev/local-lead-intelligence").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 '{
  "queries": [
    "dentists"
  ],
  "locations": [
    "Madrid, Spain"
  ]
}' |
apify call abrahan_dev/local-lead-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=abrahan_dev/local-lead-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local Lead Intelligence",
        "description": "Discover, enrich, deduplicate, and rank public local-business leads.",
        "version": "0.1",
        "x-build-id": "01UA30DRCZpyFBa8G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abrahan_dev~local-lead-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abrahan_dev-local-lead-intelligence",
                "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/abrahan_dev~local-lead-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-abrahan_dev-local-lead-intelligence",
                "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/abrahan_dev~local-lead-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-abrahan_dev-local-lead-intelligence",
                "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",
                "required": [
                    "queries",
                    "locations"
                ],
                "properties": {
                    "queries": {
                        "title": "Business queries",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Business categories or search phrases. Use distinct queries to reduce duplicates.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Cities, regions, or countries included in each Maps search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum results per query and location",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Google Maps may return fewer results than requested.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "minLength": 2,
                        "maxLength": 10,
                        "type": "string",
                        "description": "ISO language code used by Google Maps.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Optional ISO 3166-1 alpha-2 code used for phone normalization."
                    },
                    "enrichWebsite": {
                        "title": "Enrich business websites",
                        "type": "boolean",
                        "description": "Visit public website pages to identify contact and commercial signals.",
                        "default": true
                    },
                    "findEmails": {
                        "title": "Find public emails",
                        "type": "boolean",
                        "description": "Extract email addresses visibly published on the business website.",
                        "default": true
                    },
                    "findSocialProfiles": {
                        "title": "Find social profiles",
                        "type": "boolean",
                        "description": "Extract links to public business profiles on supported social networks.",
                        "default": true
                    },
                    "detectTechnologies": {
                        "title": "Detect website technologies",
                        "type": "boolean",
                        "description": "Detect CMS, analytics, pixels, forms, booking tools, WhatsApp, and schema signals.",
                        "default": true
                    },
                    "scoreLeads": {
                        "title": "Score leads",
                        "type": "boolean",
                        "description": "Calculate explainable opportunity scores and sales angles.",
                        "default": true
                    },
                    "dedupeMode": {
                        "title": "Deduplication mode",
                        "enum": [
                            "strict",
                            "loose"
                        ],
                        "type": "string",
                        "description": "Loose mode also compares normalized names, addresses, and nearby coordinates.",
                        "default": "strict"
                    },
                    "excludedDomains": {
                        "title": "Excluded domains",
                        "type": "array",
                        "description": "Domains that must not be enriched or returned.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludedPlaceIds": {
                        "title": "Excluded Google Place IDs",
                        "type": "array",
                        "description": "Google Place IDs that must not be returned.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy or custom proxy configuration used by the Google Maps collector.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "discoveryConcurrency": {
                        "title": "Google Maps concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of Google Maps pages processed in parallel. Higher values need more memory and may increase blocking.",
                        "default": 20
                    },
                    "enrichmentConcurrency": {
                        "title": "Website enrichment concurrency",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of public business website pages processed in parallel.",
                        "default": 50
                    },
                    "maxEnrichmentPages": {
                        "title": "Maximum pages per website",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum number of pages visited per business website, including its home page.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
