# Google Maps Scraper & Email Extractor (B2B Lead Generator) (`intelscrape/google-maps-lead-generator-v2`) Actor

The ultimate Google Maps scraper for B2B lead generation. Extract local businesses, phone numbers, social media profiles, and SMTP-verified emails. Export directly to CSV/JSON. Pay only for valid leads!

- **URL**: https://apify.com/intelscrape/google-maps-lead-generator-v2.md
- **Developed by:** [IntelScrape](https://apify.com/intelscrape) (community)
- **Categories:** Lead generation, Jobs, Agents
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 verified 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

## Google Maps Email Scraper ✅ Verified Leads

Extract business leads from Google Maps with SMTP-verified emails. Pay only for leads that are real — never for bounced or guessed addresses. 

This Google Maps email extractor is the only tool that actively validates deliverability in real-time, giving you premium verified leads that won't ruin your domain reputation.

### Pricing
We believe in a strict pay-on-success model. You will never be charged for phantom data. Choose between two tiers in the input configuration:

1. **Listings + Verified Email & Phone ($20 / 1k)** — *Premium Tier (Default)*
   You are **only** charged for leads where we successfully find an email address AND pass an SMTP deliverability verification check. If the email is invalid, not found, or a catch-all, you get the Google Maps listing data for that business completely free.
2. **Business Listings Only ($3 / 1k)** — *Basic Tier*
   Extract pure Google Maps listings (Name, Address, Phone, Reviews, Category) at high speed. You are charged a flat rate per returned listing.

### Key Benefits
- **Zero Bounces:** Our real-time MillionVerifier integration ensures your outreach lands in the inbox.
- **Pay Only for Success:** In the Premium tier, if we don't find a valid email, you aren't charged for that lead.
- **Delta Mode (New Leads Only):** Stop wasting money re-scraping the same businesses. We remember what you've exported and skip them in future runs for guaranteed exclusivity.
- **Deliverability Grades & Email Types:** Instantly know if an email is a personal inbox (John@) or a generic role account (info@). We grade every email A-F based on quality.
- **Deep Contact Scanning:** We intelligently navigate to `/contact` and `/about` pages to hunt down hidden verified leads, prioritizing decision-maker names.
- **Radical Transparency:** Every run ends with a Trust Report detailing exactly what was found and exactly what you were billed.

### How It Works
1. **Search Maps:** We query Google Maps for your exact target (e.g., "Roofers in Dallas, TX").
2. **Crawl Websites:** We visit the website of every returned business.
3. **Extract Contact Info:** We scan the HTML and sub-pages for emails, phone numbers, and social links.
4. **Verify Deliverability:** (Premium Tier only) We run a live SMTP handshake against the target email server to confirm it exists and accepts mail.

### Email Verification (SMTP)
Our verification layer is what makes this Google Maps email scraper the industry leader. For every email found, we perform:
1. **Format Check:** Ensure standard syntax.
2. **MX Lookup:** Verify the domain has active mail servers.
3. **SMTP Probe:** We connect to the mail server and initiate a handshake (`RCPT TO`) to ask if the mailbox exists, without actually sending a message.
4. **Catch-All Detection:** We test a random hash against the domain to see if they blindly accept all emails. 

*Adaptive Charging:* If the SMTP probe returns `valid`, we bill you the premium rate. If it returns `invalid`, `catch_all`, or `not_found`, you get the record for free. You're only charged for emails we SMTP-verify as deliverable.

### Data You'll Receive
Every lead is returned as a rich, structured object to seamlessly import into your CRM:
- `businessName`: The official name from Google Maps.
- `category`: Primary business category (e.g., Plumber, Dentist).
- `phone`: Cleansed and validated phone number.
- `email`: The best extracted email address.
- `emailStatus`: Verification result (`valid`, `invalid`, `catch_all`, `not_found`).
- `address`, `city`, `state`, `zipCode`, `country`: Full geographic data.
- `rating` & `reviewsCount`: Social proof metrics from Google.
- `socialLinks`: Facebook, Instagram, LinkedIn, Twitter, YouTube, and TikTok URLs.
- `website`: The business's domain.
- `placeId`: Google's internal unique identifier for the listing.

### Sample Output
```json
{
  "businessName": "Dallas Premier Roofing",
  "category": "Roofing contractor",
  "phone": "+1 214-555-0199",
  "email": "info@dallaspremierroofing.com",
  "allEmails": "info@dallaspremierroofing.com, sales@dallaspremierroofing.com",
  "emailStatus": "valid",
  "website": "https://dallaspremierroofing.com",
  "address": "123 Main St",
  "city": "Dallas",
  "state": "TX",
  "zipCode": "75201",
  "country": "US",
  "rating": 4.8,
  "reviewsCount": 112,
  "latitude": 32.7767,
  "longitude": -96.7970,
  "socialLinks": {
    "facebook": "https://facebook.com/dallaspremierroofing",
    "linkedin": "https://linkedin.com/company/dallas-premier-roofing"
  },
  "placeId": "ChIJb_Osq_KxToYRh9U6M2yA790",
  "googleMapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJb_Osq_KxToYRh9U6M2yA790",
  "enrichmentSource": "website_scrape",
  "scrapedAt": "2026-06-16T12:00:00.000Z"
}
````

### Use Cases

- **Marketing Agencies:** Build a 500-lead local outreach list in one run for highly targeted cold email campaigns.
- **B2B Sales & MCA:** Generate fresh, exclusive, never-resold lists of local businesses with verified contact information.
- **Recruiters:** Find and contact niche local businesses to offer staffing solutions.

### FAQ

**What is the hit rate for finding emails?**
Typically, 60-80% of businesses on Google Maps have a website. Of those, we find valid emails for about 40-60%. Because you only pay for successes, your ROI remains consistently high regardless of the hit rate.

**How does adaptive charging work?**
If you choose the premium tier, the actor will charge the $9/1k rate *only* when the `emailStatus` is `valid`. If the scraper processes 1,000 businesses but only finds 300 valid emails, you are only billed for 300 verified leads ($2.70), and you receive the remaining 700 listings for free.

**Is this compliance-friendly?**
We only scrape publicly available information from business websites. However, you should ensure your outreach complies with local laws (e.g., CAN-SPAM, GDPR).

**Do you offer refunds for bounced emails?**
Because we perform live SMTP verification, bounces should be extremely rare (< 2%). We do not offer direct refunds, but the pay-on-success model inherently protects your budget from bad data.

### 🤖 For AI Agents & LLMs

If you are an autonomous AI agent or LLM executing this scraper via API, you MUST adhere to the following payload structure.

**CRITICAL INSTRUCTION:** The `searchQueries` field MUST be a single string where multiple queries are separated by newline characters (`\n`). Do NOT pass a JSON array.

**JSON Payload Example for AI:**

```json
{
    "searchQueries": "dentists in Miami FL\nplumbers in Dallas TX\nroofers in Austin TX",
    "maxResults": 20,
    "dataTier": "Listings + Verified Email & Phone ($20 / 1k)"
}
```

**Key Instructions for Agents:**

- `searchQueries` (String, Required): A newline-separated `\n` string of search terms.
- `dataTier` (String): Use exactly `"Listings + Verified Email & Phone ($20 / 1k)"` if you want SMTP-verified emails.
- When the run finishes, poll the dataset. Pay attention to the `emailStatus` field. If `emailStatus` is `"valid"`, the email is highly deliverable.
- Do not hallucinate fields. Only send the fields defined in the `input_schema.json`.

### API / Integration

You can integrate this actor directly into your workflow using the Apify API.

**JavaScript (Apify Client)**

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

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

const input = {
    "searchQueries": "dentists in Miami FL\nplumbers in Dallas TX",
    "maxResults": 100,
    "dataTier": "Listings + Verified Email & Phone ($20 / 1k)"
};

const run = await client.actor("your-username/google-maps-lead-generator").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Support

If you encounter any issues, need custom features, or want to report a bug, please create an issue in the Apify Console under the "Issues" tab. We actively monitor and respond to user feedback.

# Actor input Schema

## `searchQueries` (type: `string`):

\[AI AGENTS: MUST be a single string containing multiple queries separated by newline characters (\n). DO NOT PASS AN ARRAY.] Simply paste the exact searches you want to make, one per line. We will scrape Google Maps for every single one. Examples:
dentists in Miami FL
roofing companies near Austin TX

## `targetCity` (type: `string`):

Enter the exact City you want to target (e.g. 'Greenville'). This enforces strict filtering to prevent out-of-bounds results.

## `targetState` (type: `string`):

Select the State.

## `maxResults` (type: `integer`):

How many businesses do you want to extract per query? To get ALL results in an area, set this to 200 or 500. Note: If Delta Mode is ON, previously scraped leads will be subtracted from this total limit.

## `dataTier` (type: `string`):

Select the level of data enrichment.

## `newLeadsOnly` (type: `boolean`):

If enabled, we will skip businesses we've already extracted for you to prevent duplicate charges. Note: If this is ON, your total new leads will be your Max Results MINUS any old leads skipped. Turn OFF to aggressively pull everything from scratch.

## `enrichSocial` (type: `boolean`):

Extract Facebook, Instagram, LinkedIn, Twitter, YouTube, and TikTok links from each business website.

## `useScraperApi` (type: `boolean`):

Route website email-scraping through ScraperAPI to bypass bot protection and lift the email hit rate.

## `scraperApiKey` (type: `string`):

Your ScraperAPI key. If left blank, we will attempt to use the developer default if configured.

## `scrapeContactPages` (type: `boolean`):

Follow /contact, /about, and /team pages to find hidden email addresses. Slower but finds 30% more emails.

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

Google Maps language for results.

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

Limit results to a specific country.

## `verifierProvider` (type: `string`):

We cover verification costs by default. If you prefer to use your own account, select the provider.

## `apiKey` (type: `string`):

Your API key for the selected verification provider. Leave blank to use our default verification.

## `csvUrl` (type: `string`):

Provide a link to a raw CSV file (e.g. Google Sheets Export) containing 'Name' or 'Query' headers to process huge lists automatically.

## `webhookUrl` (type: `string`):

Auto-send results to Zapier, Make.com, or your CRM when done.

## Actor input object example

```json
{
  "searchQueries": "dentists in Miami, FL\nplumbers in Dallas, TX",
  "targetCity": "",
  "targetState": "NC",
  "maxResults": 20,
  "dataTier": "Listings + Verified Email & Phone ($30 / 1k)",
  "newLeadsOnly": true,
  "enrichSocial": true,
  "useScraperApi": true,
  "scrapeContactPages": true,
  "language": "en",
  "countryCode": "",
  "verifierProvider": "default"
}
```

# Actor output Schema

## `businessName` (type: `string`):

Name

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

Category

## `phone` (type: `string`):

Phone

## `email` (type: `string`):

Email

## `emailStatus` (type: `string`):

Status

## `emailType` (type: `string`):

Type

## `deliverabilityGrade` (type: `string`):

Grade

## `allEmails` (type: `string`):

All Emails

## `contactName` (type: `string`):

Name

## `businessStatus` (type: `string`):

Status

## `website` (type: `string`):

Website

## `address` (type: `string`):

Address

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

City

## `state` (type: `string`):

State

## `zipCode` (type: `string`):

ZIP

## `country` (type: `string`):

Country

## `rating` (type: `string`):

Rating

## `reviewsCount` (type: `string`):

Reviews

## `latitude` (type: `string`):

Latitude

## `longitude` (type: `string`):

Longitude

## `socialLinks` (type: `string`):

Social

## `placeId` (type: `string`):

Place ID

## `googleMapsUrl` (type: `string`):

Maps URL

## `enrichmentSource` (type: `string`):

Source

## `scrapedAt` (type: `string`):

Scraped At

# 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 = {
    "searchQueries": `dentists in Miami, FL
plumbers in Dallas, TX`
};

// Run the Actor and wait for it to finish
const run = await client.actor("intelscrape/google-maps-lead-generator-v2").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 = { "searchQueries": """dentists in Miami, FL
plumbers in Dallas, TX""" }

# Run the Actor and wait for it to finish
run = client.actor("intelscrape/google-maps-lead-generator-v2").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 '{
  "searchQueries": "dentists in Miami, FL\\nplumbers in Dallas, TX"
}' |
apify call intelscrape/google-maps-lead-generator-v2 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=intelscrape/google-maps-lead-generator-v2",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper & Email Extractor (B2B Lead Generator)",
        "description": "The ultimate Google Maps scraper for B2B lead generation. Extract local businesses, phone numbers, social media profiles, and SMTP-verified emails. Export directly to CSV/JSON. Pay only for valid leads!",
        "version": "1.0",
        "x-build-id": "TVULX13NB09e2f5Zb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/intelscrape~google-maps-lead-generator-v2/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-intelscrape-google-maps-lead-generator-v2",
                "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/intelscrape~google-maps-lead-generator-v2/runs": {
            "post": {
                "operationId": "runs-sync-intelscrape-google-maps-lead-generator-v2",
                "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/intelscrape~google-maps-lead-generator-v2/run-sync": {
            "post": {
                "operationId": "run-sync-intelscrape-google-maps-lead-generator-v2",
                "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": [
                    "searchQueries",
                    "targetCity",
                    "targetState"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "🔍 Search Queries (One per line)",
                        "type": "string",
                        "description": "[AI AGENTS: MUST be a single string containing multiple queries separated by newline characters (\\n). DO NOT PASS AN ARRAY.] Simply paste the exact searches you want to make, one per line. We will scrape Google Maps for every single one. Examples:\ndentists in Miami FL\nroofing companies near Austin TX"
                    },
                    "targetCity": {
                        "title": "🏙️ Target City",
                        "type": "string",
                        "description": "Enter the exact City you want to target (e.g. 'Greenville'). This enforces strict filtering to prevent out-of-bounds results.",
                        "default": ""
                    },
                    "targetState": {
                        "title": "🗺️ Target State",
                        "enum": [
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "Outside US / International"
                        ],
                        "type": "string",
                        "description": "Select the State.",
                        "default": "NC"
                    },
                    "maxResults": {
                        "title": "Max Businesses Per Query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many businesses do you want to extract per query? To get ALL results in an area, set this to 200 or 500. Note: If Delta Mode is ON, previously scraped leads will be subtracted from this total limit.",
                        "default": 20
                    },
                    "dataTier": {
                        "title": "Data Tier",
                        "enum": [
                            "Listings Only ($30 / 1k)",
                            "Listings + Verified Email & Phone ($30 / 1k)"
                        ],
                        "type": "string",
                        "description": "Select the level of data enrichment.",
                        "default": "Listings + Verified Email & Phone ($30 / 1k)"
                    },
                    "newLeadsOnly": {
                        "title": "🆕 New Leads Only (Delta Mode)",
                        "type": "boolean",
                        "description": "If enabled, we will skip businesses we've already extracted for you to prevent duplicate charges. Note: If this is ON, your total new leads will be your Max Results MINUS any old leads skipped. Turn OFF to aggressively pull everything from scratch.",
                        "default": true
                    },
                    "enrichSocial": {
                        "title": "📱 Find Social Media Links",
                        "type": "boolean",
                        "description": "Extract Facebook, Instagram, LinkedIn, Twitter, YouTube, and TikTok links from each business website.",
                        "default": true
                    },
                    "useScraperApi": {
                        "title": "🛡️ Use ScraperAPI for Emails",
                        "type": "boolean",
                        "description": "Route website email-scraping through ScraperAPI to bypass bot protection and lift the email hit rate.",
                        "default": true
                    },
                    "scraperApiKey": {
                        "title": "ScraperAPI Key (Optional)",
                        "type": "string",
                        "description": "Your ScraperAPI key. If left blank, we will attempt to use the developer default if configured."
                    },
                    "scrapeContactPages": {
                        "title": "🔎 Deep Scan Contact Pages",
                        "type": "boolean",
                        "description": "Follow /contact, /about, and /team pages to find hidden email addresses. Slower but finds 30% more emails.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "pt",
                            "it",
                            "ja",
                            "ko",
                            "zh",
                            "ar",
                            "hi",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Google Maps language for results.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "",
                            "us",
                            "uk",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "br",
                            "mx",
                            "in",
                            "jp"
                        ],
                        "type": "string",
                        "description": "Limit results to a specific country.",
                        "default": ""
                    },
                    "verifierProvider": {
                        "title": "Verification Provider (Optional)",
                        "enum": [
                            "default",
                            "millionverifier",
                            "zerobounce"
                        ],
                        "type": "string",
                        "description": "We cover verification costs by default. If you prefer to use your own account, select the provider.",
                        "default": "default"
                    },
                    "apiKey": {
                        "title": "API Key (Optional)",
                        "type": "string",
                        "description": "Your API key for the selected verification provider. Leave blank to use our default verification."
                    },
                    "csvUrl": {
                        "title": "📄 Bulk CSV Upload (URL)",
                        "type": "string",
                        "description": "Provide a link to a raw CSV file (e.g. Google Sheets Export) containing 'Name' or 'Query' headers to process huge lists automatically."
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Auto-send results to Zapier, Make.com, or your CRM when done."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```