# Google Maps Email Extractor (`b2b_lead_generation/google-maps-email-extractor`) Actor

Google Maps email extractor that finds business emails, phone numbers, and social profiles alongside every listing, so sales teams can reach local businesses directly without manual research.

- **URL**: https://apify.com/b2b\_lead\_generation/google-maps-email-extractor.md
- **Developed by:** [B2B Lead Generation](https://apify.com/b2b_lead_generation) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Maps Email Extractor: Find Business Emails, Phone Numbers, and Social Profiles Directly from Google Maps

![Google Maps Email Extractor](https://i.imgur.com/0TO1X0V.png)

### You already know which businesses you want to reach

Search "plumbers in Austin TX" on Google Maps and you get hundreds of results. Names, addresses, star ratings, maybe a phone number. But no email. No Instagram. No LinkedIn.

To actually reach those businesses, you have to click every listing, find the website, hunt through the contact page, copy the email, paste it somewhere, and repeat. Two hundred times. For one search.

That's not a workflow. That's a full afternoon gone.

---

### The gap between finding a business and reaching one

Google Maps is the most complete local business directory on earth. It knows about every contractor, dentist, lawyer, restaurant, and agency in every city. But it gives you just enough to find them, not enough to contact them.

The email is on their website. The Instagram link is on their website. The LinkedIn page is on their website. You already know this, because you've visited those pages manually.

The problem is doing it at scale.

Sales teams lose entire days to this kind of research. Marketers build half their prospect lists by hand. Agencies spend more time finding clients than pitching them. And by the time the data is collected manually, some of it is already wrong.

There should be a way to turn any Google Maps search into a ready-to-use outreach list without touching a single website yourself.

---

### There is. It takes three steps.

Google Maps Email Extractor searches Google Maps, visits each business website, and delivers a complete contact record for every result — email, phone, and social profiles included. No manual work.

**Step 1: Add your search queries**
Use the same searches you'd type into Google Maps: "roofing contractors in Miami FL," "real estate agents in Houston TX," "wedding photographers near Atlanta GA." Add as many queries as you need.

**Step 2: Run the actor**
The actor searches each query, finds every matching business, visits the website for each one, and collects email addresses, phone numbers, Facebook pages, Instagram profiles, LinkedIn pages, and Twitter accounts — automatically, concurrently, at scale.

**Step 3: Download your contact list**
Records appear in your dataset one by one as each business finishes processing. When the run completes, export as CSV or JSON, push directly to Google Sheets, or connect to your CRM or email tool.

No spreadsheet work. No copy-pasting. No visiting a single website manually.

---

### What you get for every business

![Results table view — business email, phone, social profiles and Google Maps data side by side in one structured dataset](https://i.imgur.com/AZYHNRV.png)

![JSON output example — complete contact record with primary email, all emails, social media links, address, rating, coordinates and business hours](https://i.imgur.com/3vID9he.png)

For each business, the actor returns everything Google Maps has plus the contact details found on the business website:

**From Google Maps:**
- Business name
- Full address (street, city, state, ZIP — parsed separately)
- Primary phone number in local and international format
- All phone numbers collected (including any extra numbers found on the website)
- Website URL
- Star rating and review count
- GPS coordinates (latitude and longitude)
- Business categories
- Google Maps place ID and direct Maps link
- Neighborhood or district name
- Timezone
- Today's opening hours and current open/closed status
- Thumbnail image URL
- Business attributes (Women-owned, LGBTQ+ friendly, Veteran-owned, Black-owned, etc.)
- Accessibility features

**From the business website:**
- Primary business email address
- All email addresses found on the site
- Facebook page URL
- Instagram profile URL
- LinkedIn company page URL
- Twitter/X profile URL

```json
{
    "name": "Ultra Roof Repair Miami",
    "full_address": "333 SE 2nd Ave Suite #3995, Miami, FL 33131",
    "city": "Miami",
    "state": "FL",
    "state_full": "Florida",
    "zip_code": "33131",
    "country": "US",
    "latitude": 25.7712953,
    "longitude": -80.1897732,
    "rating": 4.9,
    "review_count": 312,
    "phone": "(305) 676-8110",
    "phone_international": "+13056768110",
    "phones": ["(305) 676-8110", "+13056768110"],
    "website": "https://ultraroofrepair.com",
    "email": "info@ultraroofrepair.com",
    "emails": ["info@ultraroofrepair.com", "owner@gmail.com"],
    "facebook": "https://www.facebook.com/ultraroofrepair",
    "instagram": "https://www.instagram.com/ultraroofrepair",
    "linkedin": null,
    "twitter": null,
    "categories": ["Roofing contractor"],
    "place_id": "ChIJpTgec7232YgRl8EICVm7KUU",
    "place_id_hex": "0x88d8b6f77e9e3893:0x554a7bb79088c197",
    "neighborhood": "Downtown Miami",
    "timezone": "America/New_York",
    "maps_path": "/g/11bzq4h5m3",
    "google_maps_url": "https://www.google.com/maps/place/?q=place_id:ChIJpTgec7232YgRl8EICVm7KUU",
    "thumbnail_url": "https://lh3.googleusercontent.com/...",
    "hours_today": "8 AM-5 PM",
    "open_now_text": "Closed · Opens 8 AM",
    "attributes": ["Women-owned"],
    "accessibility": ["Wheelchair accessible entrance", "Wheelchair accessible parking lot"],
    "query": "roof repair services in miami, FL, USA",
    "scraped_at": "2026-05-20T10:22:31.445Z"
}
````

### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name as listed on Google Maps |
| `full_address` | string | Complete street address including city, state, and ZIP |
| `city` | string | City extracted from the address |
| `state` | string | State abbreviation (e.g. FL, NY, CA) |
| `state_full` | string | Full state name (e.g. Florida, New York, California) |
| `zip_code` | string | ZIP or postal code |
| `country` | string | Two-letter country code (e.g. US, GB) |
| `latitude` | number | GPS latitude coordinate |
| `longitude` | number | GPS longitude coordinate |
| `rating` | number | Average star rating (1.0 to 5.0) |
| `review_count` | integer | Total number of Google Maps reviews |
| `phone` | string | Primary phone in local format, e.g. (305) 555-1234 |
| `phone_international` | string | Primary phone in international format, e.g. +13055551234 |
| `phones` | array | All phone numbers collected, including any extra numbers found on the website |
| `website` | string | Business website URL |
| `email` | string | Primary business email address extracted from the website |
| `emails` | array | All email addresses found on the business website |
| `facebook` | string | Facebook page or profile URL |
| `instagram` | string | Instagram profile URL |
| `linkedin` | string | LinkedIn company page URL |
| `twitter` | string | Twitter/X profile URL |
| `categories` | array | Business category labels from Google Maps |
| `place_id` | string | Unique Google Maps place identifier (ChIJ... format) |
| `place_id_hex` | string | Hexadecimal internal place identifier |
| `neighborhood` | string | Neighborhood or district name |
| `timezone` | string | IANA timezone, e.g. America/New\_York |
| `maps_path` | string | Short Google Maps path, e.g. /g/abc123 |
| `google_maps_url` | string | Direct Google Maps URL for this business |
| `thumbnail_url` | string | Business thumbnail image URL from Google |
| `hours_today` | string | Today's hours, e.g. 8 AM-5 PM or Open 24 hours |
| `open_now_text` | string | Current status, e.g. Open or Closed · Opens 8 AM |
| `attributes` | array | Identity labels: Women-owned, LGBTQ+ friendly, Veteran-owned, etc. |
| `accessibility` | array | Accessibility features: Wheelchair accessible entrance, etc. |
| `query` | string | The search query that returned this result |
| `scraped_at` | string | ISO 8601 timestamp of when this record was collected |

***

### What you can do with this data

Most people doing outreach manually research 20 to 30 businesses per hour. Running a query here takes minutes and returns hundreds of enriched contacts. Here is what this actually gets used for:

- **Cold email outreach**: build targeted prospect lists with verified email addresses for contractors, dentists, lawyers, gyms, restaurants, or any category in any city — ready to import into your email tool
- **B2B lead generation**: collect names, phone numbers, emails, and LinkedIn pages for direct outreach campaigns across specific ZIP codes or neighborhoods
- **Social media and ad targeting**: find Instagram and Facebook pages for local businesses to run geo-targeted campaigns or identify partnership and influencer opportunities
- **Sales prospecting**: get direct contact emails and phone numbers for decision-makers at local businesses without spending hours on manual research
- **CRM enrichment**: append verified addresses, phone numbers, emails, and social profiles to existing records using Google Maps place IDs as the linking key
- **Agency client prospecting**: search by industry and city, then filter for businesses without websites or with thin social presence to find clients who need help
- **Market research**: run the same category query across multiple cities, compare result counts and ratings, and identify underserved markets
- **Local SEO benchmarking**: pull competitor ratings, review counts, and social presence for every listing in a category to see exactly where each one stands
- **Franchise scouting**: query multiple cities with the same category search to find coverage gaps before committing to a market
- **Real estate research**: find businesses near a target property by ZIP code and collect contact details to build neighborhood profiles or tenant partnership lists
- **Event and vendor sourcing**: find caterers, photographers, venues, and florists in any city with their direct contact details in a single run
- **Directory building**: collect complete business listings with contact information for an entire city or industry to power a local directory or lead database
- **International outreach**: works in any country — set language and country to collect business emails and social profiles in the UK, Canada, Japan, Germany, and more

***

### Without this, here's what you're doing instead

You're spending three to four hours building a 200-contact list that should take ten minutes. You're paying list vendors for data that hasn't been updated since last year. You're sending outreach to phone numbers only because the email took too long to find. You're watching competitors move faster on the same prospects because they are not doing the same manual work you are.

Every hour spent visiting websites and copying emails is an hour not spent on the actual outreach. The research itself closes no deals.

***

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | required | One or more search queries. Each can return up to 200 results. |
| `language` | string | `en` | Language code for results (e.g. `en`, `es`, `fr`, `ja`). |
| `country` | string | `us` | Two-letter country code to localize results (e.g. `us`, `gb`, `ca`). |
| `maxResultsPerQuery` | integer | `10` | Max results per query. Default is 10, maximum is 200. The actor paginates automatically. |
| `maxTotalResults` | integer | `50000` | Total result cap across all queries per run. |
| `proxyConfiguration` | object | Datacenter (Anywhere) | Proxy type and location. Supports Datacenter, Residential, and custom proxies. Optional. |

#### Example input

```json
{
    "searchQueries": [
        "roof repair services in miami, FL, USA",
        "plumbers in los angeles, CA",
        "dentist near downtown chicago, IL",
        "plumbers near 90210",
        "restaurants near zip 10001 New York",
        "coffee shops near Times Square New York",
        "electricians in 77001 Houston TX",
        "italian restaurants in new york, NY",
        "real estate agents in houston, TX",
        "lawyers in washington, DC",
        "auto repair shops in phoenix, AZ",
        "gyms near boston, MA",
        "electricians in seattle, WA",
        "hotels in las vegas, NV",
        "wedding photographers in atlanta, GA",
        "pediatricians in dallas, TX",
        "dog groomers in denver, CO",
        "landscaping services in portland, OR",
        "plumber repair in London, UK",
        "gyms near 94102 San Francisco CA"
    ],
    "language": "en",
    "country": "us",
    "maxResultsPerQuery": 100,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### FAQ

**What email addresses does this actor collect?**
The actor visits each business website and extracts email addresses publicly listed there. It returns both business domain emails (e.g. info@company.com) and personal contact emails (e.g. owner@gmail.com) if they appear on the site. The `email` field is the primary address and `emails` contains the full list found.

**What social media platforms are supported?**
Facebook, Instagram, LinkedIn, and Twitter/X. One URL per platform per business is returned.

**What happens if a business has no website or no email?**
The `email`, `emails`, `facebook`, `instagram`, `linkedin`, and `twitter` fields return null or empty arrays. All Google Maps data — address, phone, rating, coordinates — is still returned for every business regardless.

**How many results does each query return?**
Up to 10 per query by default. You can increase this up to 200 per query. The actor paginates automatically. If Google has fewer results for a specific query, you get whatever is available.

**Can I search by ZIP code?**
Yes. Queries like `"plumbers near 90210"` or `"dentists in zip 10001 New York"` work exactly the same as city-name queries.

**Does it work outside the US?**
Yes. Set `language` and `country` to match your target region. For example, `language: "en"`, `country: "gb"` for the UK, or `language: "ja"`, `country: "jp"` for Japan. Phone numbers and addresses are returned in local format.

**Are duplicate businesses removed?**
Yes. Results are deduplicated by Google Maps place ID across all queries in the same run. If the same business appears in two queries, you get one record.

**Do results appear while the run is still going?**
Yes. Each business record is pushed to your dataset the moment its contact extraction finishes, so data appears one record at a time as the actor works — no waiting for the full run to complete.

**Can I run many queries at once?**
Yes, up to 5 queries run in parallel. Pass in hundreds and they process in batches automatically.

***

### Integrations

Connect Google Maps Email Extractor with other tools via [Apify integrations](https://apify.com/integrations). Works with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and others. [Webhooks](https://docs.apify.com/integrations/webhooks) let you trigger downstream actions the moment results are ready.

***

### Powered by EmailReach.io

Email and social media extraction is powered by [EmailReach.io](https://emailreach.io), which helps discover publicly listed emails, phone numbers, and social profiles from business websites. Without it, this actor would only return data directly available from Google Maps.

***

[![Try Google Maps Email Extractor](https://i.imgur.com/Sn356VX.png)](https://apify.com/kawsarlog/google-maps-email-extractor)

# Actor input Schema

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

One or more Google Maps search queries. Each query can return up to 200 results. Use specific phrases like 'plumbers in Austin, TX', 'dentist near 10001', or 'restaurants in downtown Chicago, IL' for best results.

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

Language code for results (e.g. 'en' for English, 'es' for Spanish, 'fr' for French, 'ja' for Japanese). Affects the language of returned business names and addresses.

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

Two-letter country code to localize results (e.g. 'us', 'gb', 'ca', 'au', 'jp'). Use this to bias results toward a specific country.

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

Maximum number of results to collect per search query. The default is 10. You can increase this up to 200 per query. The actor paginates automatically to reach this number. Fewer results are returned if Google has less data for that query.

## `maxTotalResults` (type: `integer`):

Maximum total results to collect across all queries in one run. Use this as a safety cap for large query lists.

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

Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect.

## Actor input object example

```json
{
  "searchQueries": [
    "roof repair services in miami, FL, USA",
    "dentist near downtown chicago, IL",
    "plumbers near 90210",
    "restaurants near zip 10001 New York",
    "lawyers in washington, DC",
    "coffee shops near Times Square New York",
    "electricians in 77001 Houston TX",
    "italian restaurants in new york, NY",
    "real estate agents in houston, TX",
    "auto repair shops in phoenix, AZ",
    "gyms near boston, MA",
    "electricians in seattle, WA",
    "hotels in las vegas, NV",
    "wedding photographers in atlanta, GA",
    "dog groomers in denver, CO",
    "landscaping services in portland, OR",
    "plumber repair in London, UK",
    "restaurants in Tokyo Japan",
    "pediatricians in dallas, TX",
    "gyms near 94102 San Francisco CA"
  ],
  "language": "en",
  "country": "us",
  "maxResultsPerQuery": 10,
  "maxTotalResults": 50000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "plumbers in Los Angeles, CA"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/google-maps-email-extractor").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": ["plumbers in Los Angeles, CA"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/google-maps-email-extractor").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": [
    "plumbers in Los Angeles, CA"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call b2b_lead_generation/google-maps-email-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Email Extractor",
        "description": "Google Maps email extractor that finds business emails, phone numbers, and social profiles alongside every listing, so sales teams can reach local businesses directly without manual research.",
        "version": "0.0",
        "x-build-id": "4mFcF4Zzfr4v3nEdi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_lead_generation~google-maps-email-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_lead_generation-google-maps-email-extractor",
                "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/b2b_lead_generation~google-maps-email-extractor/runs": {
            "post": {
                "operationId": "runs-sync-b2b_lead_generation-google-maps-email-extractor",
                "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/b2b_lead_generation~google-maps-email-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_lead_generation-google-maps-email-extractor",
                "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"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more Google Maps search queries. Each query can return up to 200 results. Use specific phrases like 'plumbers in Austin, TX', 'dentist near 10001', or 'restaurants in downtown Chicago, IL' for best results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for results (e.g. 'en' for English, 'es' for Spanish, 'fr' for French, 'ja' for Japanese). Affects the language of returned business names and addresses.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code to localize results (e.g. 'us', 'gb', 'ca', 'au', 'jp'). Use this to bias results toward a specific country.",
                        "default": "us"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Query (Default: 10, Adjustable Up to 200)",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of results to collect per search query. The default is 10. You can increase this up to 200 per query. The actor paginates automatically to reach this number. Fewer results are returned if Google has less data for that query.",
                        "default": 10
                    },
                    "maxTotalResults": {
                        "title": "Max total results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total results to collect across all queries in one run. Use this as a safety cap for large query lists.",
                        "default": 50000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to use for requests. Helps avoid IP blocking and rate limits. Datacenter proxies are fastest; Residential proxies are harder to detect."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
