# Local Business Lead Finder with Verified Emails (`stevennguyen/local-business-lead-intelligence`) Actor

Turn Google Maps exports, CSVs, Apify datasets, or local business discovery into deduped CRM-ready leads with public emails, social links, lead scoring, and new-leads-only monitoring.

- **URL**: https://apify.com/stevennguyen/local-business-lead-intelligence.md
- **Developed by:** [Steven Nguyen](https://apify.com/stevennguyen) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Business Lead Finder with Verified Emails

Turn Google Maps exports, Apify datasets, CSVs, or local business discovery queries into deduped, CRM-ready leads with public emails, social links, transparent lead scoring, and new-leads-only monitoring.

This Actor is designed for the sales workflow after discovery. It is not another generic Google Maps scraper. Use a broad scraper when you need every raw Maps field. Use this Actor when you want a clean list of businesses worth contacting.

### What this Actor does

- Accepts seed businesses as JSON, CSV paste, or an Apify dataset ID
- Works well with Google Maps Scraper / Google Maps Extractor output datasets
- Optionally discovers businesses from OpenStreetMap/Overpass without a Google API key
- Normalizes common fields such as company/name/title, website/domain, phone, rating, review count, category, Maps URL, and place ID
- Dedupes across imported rows, searches, and recurring runs
- Visits business websites and contact/about pages to find public business emails
- Extracts social profiles from websites
- Checks email domains with DNS MX lookup
- Scores leads from 0 to 100 and explains why
- Adds HubSpot, Salesforce, and Apollo-style helper columns
- Tracks `new`, `updated`, and `unchanged` leads across runs

### Common use cases

#### Enrich a Google Maps Scraper dataset

1. Run a Google Maps scraper or extractor.
2. Copy its dataset ID.
3. Run this Actor with that dataset ID.
4. Export the CRM-ready output view.

```json
{
  "inputDatasetId": "YOUR_DATASET_ID",
  "verticalPreset": "roofing",
  "findEmails": true,
  "verifyEmailMx": true,
  "outputPreset": "hubspot",
  "onlyWithWebsite": true,
  "minLeadScore": 60,
  "maxLeads": 1000
}
````

#### Paste CSV rows

```json
{
  "csvText": "Company,Website,Phone,Rating,Reviews Count\nABC Roofing,https://abcroofing.example,+1 555 0100,4.8,122",
  "verticalPreset": "roofing",
  "findEmails": true,
  "outputPreset": "salesforce"
}
```

#### Discover local businesses without Google Maps

```json
{
  "verticalPreset": "hvac",
  "locations": ["Austin, Texas", "Round Rock, Texas"],
  "maxResultsPerQuery": 50,
  "findEmails": true,
  "requireEmail": true,
  "outputPreset": "hubspot"
}
```

OpenStreetMap discovery coverage varies by city and vertical, but it is useful for low-risk seed generation.

#### Weekly new-leads-only monitor

Run the same input on a schedule with:

```json
{
  "inputDatasetId": "YOUR_DATASET_ID",
  "onlyNewSinceLastRun": true,
  "findEmails": true,
  "requireEmail": true
}
```

The Actor stores lead fingerprints in the default key-value store and emits only new or changed leads when `onlyNewSinceLastRun` is enabled.

### Input sources

| Input | Best for |
|---|---|
| `businesses` | Manual seeds or API calls |
| `csvText` | Google Maps CSV/export paste |
| `inputDatasetId` | Chaining from Google Maps Scraper or any Apify Actor |
| `verticalPreset` + `locations` | OpenStreetMap discovery |
| `searchQueries` | Custom OpenStreetMap discovery queries |

### Vertical presets

Current presets:

- roofing
- HVAC
- plumbing
- dentists
- med spas
- law firms
- restaurants
- auto repair
- cleaning services

Presets generate discovery terms and add scoring hints. You can also use `businessType` for custom niches.

### Output fields

Core output:

| Field | Meaning |
|---|---|
| `businessName` | Normalized business/company name |
| `category` | Business category/source category |
| `address`, `city`, `state`, `country` | Location fields |
| `phone` | Business phone if present |
| `website`, `domain` | Normalized website/domain |
| `emails`, `primaryEmail` | Public emails found on website/contact pages |
| `emailSources` | Source page for each discovered email |
| `emailVerification` | DNS MX-level email-domain check |
| `socialProfiles` | Public social links found on the website |
| `rating`, `reviewCount` | Reputation fields if present in source data |
| `googleMapsUrl`, `placeId`, `sourceUrl` | Source identity/audit fields |
| `leadScore` | 0-100 score |
| `leadScoreReasons` | Human-readable scoring reasons |
| `changeType` | `new`, `updated`, or `unchanged` |
| `dedupeKey`, `fingerprint` | Stable IDs for monitoring and dedupe |
| `skippedReasons` | Why a lead failed qualification filters, when applicable |

CRM output presets add helper fields for HubSpot, Salesforce, or Apollo-style CSV imports.

### Qualification filters

Use these to make output more sales-ready:

- `onlyWithWebsite`: skip leads without websites
- `requireEmail`: skip leads where no public business email is found
- `minLeadScore`: skip leads below a score threshold
- `minRating`: down-score or filter low-rated businesses
- `minReviews`: down-score or filter businesses with too few reviews
- `excludeChains`: down-rank obvious chains/franchises

### How this differs from Google Maps Scraper

| Google Maps Scraper | This Actor |
|---|---|
| Broad Maps data extraction | CRM-ready lead workflow |
| Raw place records | Scored, deduped, contact-ready leads |
| Great for every Maps field | Great for outreach lists |
| User cleans and transforms output | Output views are built for CRMs |
| Add-ons for enrichment | Contact enrichment is core workflow |
| One-off scraping focus | New/updated lead monitoring built in |
| Direct Google Maps scraping | Accepts Maps exports/datasets, CSVs, and OSM discovery |

### Pricing

This Actor is configured for pay-per-event pricing.

| Event | Price | What it means |
|---|---:|---|
| Actor start | $0.00005 | Automatically charged when a run starts, using Apify's synthetic `apify-actor-start` event. |
| CRM-ready lead | $0.003 | Charged for each enriched lead record written to the default dataset, using Apify's synthetic `apify-default-dataset-item` event. |

The primary price is $3.00 per 1,000 CRM-ready lead records. Platform usage is not separately passed through to users.

Apify enforces a two-week delay for pricing model changes. The PPE configuration for this Actor is scheduled to take effect on 2026-07-20.

### Caveats

- This Actor does not directly scrape Google Maps pages. It enriches Google Maps exports/datasets or other local business seed data.
- It does not require a Google API key.
- Email verification is DNS MX-level only. It checks whether the domain is configured to receive mail, not whether an individual mailbox exists.
- OpenStreetMap discovery is best-effort and coverage varies.
- Respect applicable privacy laws, platform terms, and email outreach rules. Prefer business contact emails, keep source URLs, and honor opt-out requests.

### Recommended marketplace positioning

Use this when the buyer wants leads, not raw map data:

> Find local businesses, enrich their websites for public emails and social links, score lead quality, dedupe results, and export CRM-ready records.

# Actor input Schema

## `businesses` (type: `array`):

Known businesses to enrich. Paste Google Maps Scraper output rows, CSV-transformed rows, or manual seeds. Fields can include name/title, website, phone, address, city, state, category, rating, reviewCount, googleMapsUrl, and placeId.

## `csvText` (type: `string`):

Optional CSV paste. Useful for Google Maps exports. Header names such as Company, Website, Phone, Reviews Count, Rating, Category, Google Maps URL are auto-mapped.

## `inputDatasetId` (type: `string`):

Optional Apify dataset ID to enrich, for example the dataset produced by Google Maps Scraper or another Actor.

## `inputDatasetItemsLimit` (type: `integer`):

Maximum records to load from the input dataset.

## `verticalPreset` (type: `string`):

Adds buyer-specific discovery terms and lead-scoring hints.

## `businessType` (type: `string`):

Optional custom business type used for discovery query generation and context, e.g. storm damage roof repair.

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

Optional locations used with vertical preset/business type to generate OpenStreetMap discovery queries, e.g. Austin, TX.

## `searchQueries` (type: `array`):

Optional keyless discovery queries for Overpass/OpenStreetMap, e.g. roofing contractor in Austin, TX. This is a discovery fallback, not Google Maps scraping.

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

Maximum businesses to pull from each OSM discovery query.

## `maxLeads` (type: `integer`):

Maximum unique businesses to process after combining and deduping seeds, CSV, dataset, and discovery results.

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

Fetch business websites and contact/about pages to find public business email addresses.

## `verifyEmailMx` (type: `boolean`):

Performs DNS MX checks on discovered email domains. This is not mailbox-level verification.

## `includeSocialProfiles` (type: `boolean`):

Extract public Facebook, Instagram, LinkedIn, YouTube, TikTok, X/Twitter, and Pinterest profile links from business websites.

## `excludeChains` (type: `boolean`):

Apply a score penalty to obvious chain/franchise businesses so independent local leads rank higher.

## `onlyWithWebsite` (type: `boolean`):

Skip records that have no website after normalization.

## `requireEmail` (type: `boolean`):

Skip records when no public business email is found.

## `minLeadScore` (type: `integer`):

Skip leads below this score. Set 0 to keep all scored leads.

## `minRating` (type: `number`):

Businesses below this rating are still output unless qualification filters are enabled, but scoring marks them lower.

## `minReviews` (type: `integer`):

Businesses below this review count are still output unless qualification filters are enabled, but scoring marks them lower.

## `onlyNewSinceLastRun` (type: `boolean`):

Uses the default key-value store to compare stable fingerprints across runs. Unchanged leads are counted but not pushed to the dataset.

## `outputPreset` (type: `string`):

Adds preset-specific CRM helper fields.

## `contactPaths` (type: `array`):

Optional extra website paths to check for contact details, e.g. /team, /locations, /estimate.

## `maxPagesPerWebsite` (type: `integer`):

Maximum website pages to fetch per business for email/social extraction.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds to wait for each website/contact page request.

## Actor input object example

```json
{
  "businesses": [
    {
      "name": "Apify Technologies",
      "website": "https://apify.com",
      "category": "Software company",
      "address": "Prague, Czechia",
      "rating": 4.8,
      "reviewCount": 100,
      "sourceUrl": "https://apify.com"
    }
  ],
  "csvText": "",
  "inputDatasetId": "",
  "inputDatasetItemsLimit": 1000,
  "verticalPreset": "custom",
  "businessType": "",
  "locations": [],
  "searchQueries": [],
  "maxResultsPerQuery": 50,
  "maxLeads": 1000,
  "findEmails": true,
  "verifyEmailMx": true,
  "includeSocialProfiles": true,
  "excludeChains": true,
  "onlyWithWebsite": false,
  "requireEmail": false,
  "minLeadScore": 0,
  "minRating": 0,
  "minReviews": 0,
  "onlyNewSinceLastRun": false,
  "outputPreset": "standard",
  "contactPaths": [],
  "maxPagesPerWebsite": 5,
  "requestTimeoutSecs": 15
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("stevennguyen/local-business-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("stevennguyen/local-business-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 '{}' |
apify call stevennguyen/local-business-lead-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local Business Lead Finder with Verified Emails",
        "description": "Turn Google Maps exports, CSVs, Apify datasets, or local business discovery into deduped CRM-ready leads with public emails, social links, lead scoring, and new-leads-only monitoring.",
        "version": "0.2",
        "x-build-id": "UGJoQlvtbQsj6cOrG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stevennguyen~local-business-lead-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stevennguyen-local-business-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/stevennguyen~local-business-lead-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-stevennguyen-local-business-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/stevennguyen~local-business-lead-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-stevennguyen-local-business-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",
                "properties": {
                    "businesses": {
                        "title": "Seed businesses",
                        "type": "array",
                        "description": "Known businesses to enrich. Paste Google Maps Scraper output rows, CSV-transformed rows, or manual seeds. Fields can include name/title, website, phone, address, city, state, category, rating, reviewCount, googleMapsUrl, and placeId.",
                        "default": [
                            {
                                "name": "Apify Technologies",
                                "website": "https://apify.com",
                                "category": "Software company",
                                "address": "Prague, Czechia",
                                "rating": 4.8,
                                "reviewCount": 100,
                                "sourceUrl": "https://apify.com"
                            }
                        ]
                    },
                    "csvText": {
                        "title": "CSV rows to enrich",
                        "type": "string",
                        "description": "Optional CSV paste. Useful for Google Maps exports. Header names such as Company, Website, Phone, Reviews Count, Rating, Category, Google Maps URL are auto-mapped.",
                        "default": ""
                    },
                    "inputDatasetId": {
                        "title": "Input dataset ID",
                        "type": "string",
                        "description": "Optional Apify dataset ID to enrich, for example the dataset produced by Google Maps Scraper or another Actor.",
                        "default": ""
                    },
                    "inputDatasetItemsLimit": {
                        "title": "Dataset item limit",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum records to load from the input dataset.",
                        "default": 1000
                    },
                    "verticalPreset": {
                        "title": "Vertical preset",
                        "enum": [
                            "custom",
                            "roofing",
                            "hvac",
                            "plumbing",
                            "dentists",
                            "med_spas",
                            "law_firms",
                            "restaurants",
                            "auto_repair",
                            "cleaning"
                        ],
                        "type": "string",
                        "description": "Adds buyer-specific discovery terms and lead-scoring hints.",
                        "default": "custom"
                    },
                    "businessType": {
                        "title": "Custom business type",
                        "type": "string",
                        "description": "Optional custom business type used for discovery query generation and context, e.g. storm damage roof repair.",
                        "default": ""
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional locations used with vertical preset/business type to generate OpenStreetMap discovery queries, e.g. Austin, TX.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "OpenStreetMap discovery queries",
                        "type": "array",
                        "description": "Optional keyless discovery queries for Overpass/OpenStreetMap, e.g. roofing contractor in Austin, TX. This is a discovery fallback, not Google Maps scraping.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max OSM results per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum businesses to pull from each OSM discovery query.",
                        "default": 50
                    },
                    "maxLeads": {
                        "title": "Max businesses to process",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum unique businesses to process after combining and deduping seeds, CSV, dataset, and discovery results.",
                        "default": 1000
                    },
                    "findEmails": {
                        "title": "Find emails on websites",
                        "type": "boolean",
                        "description": "Fetch business websites and contact/about pages to find public business email addresses.",
                        "default": true
                    },
                    "verifyEmailMx": {
                        "title": "Check email domain MX records",
                        "type": "boolean",
                        "description": "Performs DNS MX checks on discovered email domains. This is not mailbox-level verification.",
                        "default": true
                    },
                    "includeSocialProfiles": {
                        "title": "Extract social profile links",
                        "type": "boolean",
                        "description": "Extract public Facebook, Instagram, LinkedIn, YouTube, TikTok, X/Twitter, and Pinterest profile links from business websites.",
                        "default": true
                    },
                    "excludeChains": {
                        "title": "Down-rank likely chains/franchises",
                        "type": "boolean",
                        "description": "Apply a score penalty to obvious chain/franchise businesses so independent local leads rank higher.",
                        "default": true
                    },
                    "onlyWithWebsite": {
                        "title": "Output only leads with websites",
                        "type": "boolean",
                        "description": "Skip records that have no website after normalization.",
                        "default": false
                    },
                    "requireEmail": {
                        "title": "Output only leads with emails",
                        "type": "boolean",
                        "description": "Skip records when no public business email is found.",
                        "default": false
                    },
                    "minLeadScore": {
                        "title": "Minimum lead score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Skip leads below this score. Set 0 to keep all scored leads.",
                        "default": 0
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Businesses below this rating are still output unless qualification filters are enabled, but scoring marks them lower.",
                        "default": 0
                    },
                    "minReviews": {
                        "title": "Minimum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Businesses below this review count are still output unless qualification filters are enabled, but scoring marks them lower.",
                        "default": 0
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only output new/changed leads",
                        "type": "boolean",
                        "description": "Uses the default key-value store to compare stable fingerprints across runs. Unchanged leads are counted but not pushed to the dataset.",
                        "default": false
                    },
                    "outputPreset": {
                        "title": "Output preset",
                        "enum": [
                            "standard",
                            "hubspot",
                            "salesforce",
                            "apollo"
                        ],
                        "type": "string",
                        "description": "Adds preset-specific CRM helper fields.",
                        "default": "standard"
                    },
                    "contactPaths": {
                        "title": "Extra contact paths",
                        "type": "array",
                        "description": "Optional extra website paths to check for contact details, e.g. /team, /locations, /estimate.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerWebsite": {
                        "title": "Max pages per website",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Maximum website pages to fetch per business for email/social extraction.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Website request timeout",
                        "minimum": 3,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum seconds to wait for each website/contact page request.",
                        "default": 15
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
