# Google AI Overview Scraper (`mof1re/google-ai-scraper`) Actor

Extracts emails, phone numbers, and website links from Google's AI Overview answers. Feed in search queries (e.g. "Company X CFO email") and get structured contact data back — deduplicated, typed (phone/fax), and ready for lead lists, CRM enrichment, or research.

- **URL**: https://apify.com/mof1re/google-ai-scraper.md
- **Developed by:** [Vladimir Efimenco](https://apify.com/mof1re) (community)
- **Categories:** Lead generation, Social media, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 AI Overview Scraper

Google's AI Overview shows up at the top of search results for a huge range of queries now, summarizing whatever it can pull together from across the web. This scraper sends your search queries to Google, grabs that AI Overview answer, and hands it back to you clean and ready to use. You get the full text of the answer every time, and if what you're after happens to be a contact detail, it'll also go ahead and pull out any emails, phone numbers, and links it finds inside the answer for you.

![AI Overview example - email, phone, and link highlighted](https://i.imgur.com/fgoEkVs.png)

### 🎯 What you can use this for

- Pulling the raw AI Overview text for any query, for research, monitoring, content, or just seeing what Google is telling people about a topic
- Building a lead list for outreach, where you already have a company or a person's name and just need the email or phone number
- Enriching an existing CRM or spreadsheet that has names and companies but is missing contact info
- Sourcing candidates for recruiting, when you need a way to reach a hiring manager or a specific person at a company
- Quick due diligence, checking whether a business or organization has a public, current contact listed anywhere
- Journalists or researchers who need a fast way to find a public contact for a comment or follow-up
- Tracking how Google's AI Overview answers change over time for the same query

### ⚙️ How it works

You give it a list of search queries, the same way you'd type them into Google. Something like:

````

Acme Corp CFO email
John Smith CTO Acme Corp phone
Some Bank <Person Name> phone and email
Spacex Elon Musk phone and email

````

The scraper runs each query and gives you back the full AI Overview answer as plain text, every time. On top of that, you can optionally turn on extraction for:

- **Emails** - found and deduplicated, so you don't get the same address twice even if it's mentioned more than once
- **Phone numbers** - matched against US phone formats, with a best guess at whether it's a phone or a fax line based on the words around it
- **Links** - website URLs mentioned in the answer, including ones written without "https://" in front

Turn any of these off if you just want the raw answer text and plan to do your own thing with it.

### 🔧 Input options

| Field | Description |
|---|---|
| `queries` | List of search queries to run, one AI Overview answer per query |
| `parseEmails` | Turn email extraction on or off |
| `parsePhones` | Turn phone number extraction on or off |
| `parseUrls` | Turn link extraction on or off |
| `language` | Language Google should reply in |
| `country` | Country Google should treat the search as coming from |

### 📋 Example output

```json
[
  {
    "query": "Happen Bank <person name> phone and email",
    "emails": ["someemail@domain.com"],
    "phones": [
      { "raw": "123-456-4111", "digits": "1234564111", "type": "phone" }
    ],
    "urls": ["happen.com"],
    "raw_result": "The primary contact for..."
  }
]
````

### ❓ FAQ

**Does this need an AI Overview to already be showing on Google for that query?** Yes. If Google doesn't generate an AI Overview for a particular query, that query comes back empty, since there's nothing to grab.

**Will it always find an email or phone number?** No, only if the AI Overview actually mentions one. This tool reads what's already publicly surfaced by Google, it doesn't go dig through a website on its own.

**Can I search in a language other than English?** Yes, pick your language and country in the input settings and Google will respond in that language where possible.

**Is this accurate?** It's only as accurate as what Google's AI Overview says. AI-generated summaries can occasionally be outdated or wrong, so it's worth spot-checking anything important before you rely on it.

**Is this legal?** This tool extracts publicly available information that Google itself already surfaces to any regular search user. You're responsible for complying with applicable data protection laws for your specific use case.

### 💳 Pricing

Pay-per-result. You're charged for results actually delivered, not for queries that come back empty.

### ⚠️ Notes

- Free-tier accounts are capped at a small number of queries per run. Upgrade to a paid Apify plan for full volume.
- Not every query will return an AI Overview. Google decides on its own when to show one.

### 🔗 See also

Need a scraper for another platform? Check out:

- [Trustpilot Reviews Scraper](https://apify.com/mof1re/trustpilot-scraper-fast-browserlessapif)
- [AirBNB Reviews Scraper](https://apify.com/mof1re/airbnb-reviews-scraper-browserless)
- [TripAdvisor Reviews Scraper](https://apify.com/mof1re/tripadvisor-reviews-scraper-browserless)
- [Arbeitsagentur Scraper, Most Complete Result Dataset on Apify](https://apify.com/mof1re/arbeitsagentur-scraper)

# Actor input Schema

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

List of search queries to run against Google (e.g. "Acme Corp CFO email", "John Smith CTO Acme Corp phone"). Each query is processed separately and its Google AI Overview answer is scanned for contact details.

## `parseEmails` (type: `boolean`):

Extract and deduplicate email addresses found in the AI answer.

## `parsePhones` (type: `boolean`):

Extract US-format phone numbers, labeling each as phone or fax where the surrounding text indicates the type.

## `parseUrls` (type: `boolean`):

Extract website URLs found in the AI answer, including domains written without a protocol (e.g. example.com).

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

Language Google should use for the search results (equivalent to Google's lr parameter).

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

Country Google should treat the search as coming from (equivalent to Google's gl parameter). Affects result localization.

## Actor input object example

```json
{
  "queries": [
    "Happen Bank Scott Sanborn phone and email",
    "Spacex Elon Musk phone and email"
  ],
  "parseEmails": true,
  "parsePhones": true,
  "parseUrls": true,
  "language": "English",
  "country": "United States"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "Happen Bank Scott Sanborn phone and email",
        "Spacex Elon Musk phone and email"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mof1re/google-ai-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": [
        "Happen Bank Scott Sanborn phone and email",
        "Spacex Elon Musk phone and email",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mof1re/google-ai-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "Happen Bank Scott Sanborn phone and email",
    "Spacex Elon Musk phone and email"
  ]
}' |
apify call mof1re/google-ai-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google AI Overview Scraper",
        "description": "Extracts emails, phone numbers, and website links from Google's AI Overview answers. Feed in search queries (e.g. \"Company X CFO email\") and get structured contact data back — deduplicated, typed (phone/fax), and ready for lead lists, CRM enrichment, or research.",
        "version": "0.1",
        "x-build-id": "znf8eQboYbkHjsbAI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mof1re~google-ai-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mof1re-google-ai-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/mof1re~google-ai-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mof1re-google-ai-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/mof1re~google-ai-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mof1re-google-ai-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🔍 Search queries",
                        "type": "array",
                        "description": "List of search queries to run against Google (e.g. \"Acme Corp CFO email\", \"John Smith CTO Acme Corp phone\"). Each query is processed separately and its Google AI Overview answer is scanned for contact details.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "parseEmails": {
                        "title": "📧 Extract emails",
                        "type": "boolean",
                        "description": "Extract and deduplicate email addresses found in the AI answer.",
                        "default": true
                    },
                    "parsePhones": {
                        "title": "📞 Extract phone numbers",
                        "type": "boolean",
                        "description": "Extract US-format phone numbers, labeling each as phone or fax where the surrounding text indicates the type.",
                        "default": true
                    },
                    "parseUrls": {
                        "title": "🔗 Extract website links",
                        "type": "boolean",
                        "description": "Extract website URLs found in the AI answer, including domains written without a protocol (e.g. example.com).",
                        "default": true
                    },
                    "language": {
                        "title": "🌐 Results language",
                        "enum": [
                            "English",
                            "Russian",
                            "Spanish",
                            "German",
                            "French",
                            "Portuguese",
                            "Italian",
                            "Dutch",
                            "Polish",
                            "Turkish",
                            "Arabic",
                            "Hebrew",
                            "Chinese (Simplified)",
                            "Chinese (Traditional)",
                            "Japanese",
                            "Korean",
                            "Hindi",
                            "Indonesian",
                            "Vietnamese",
                            "Thai",
                            "Ukrainian",
                            "Romanian",
                            "Greek",
                            "Czech",
                            "Swedish",
                            "Danish",
                            "Finnish",
                            "Norwegian",
                            "Hungarian",
                            "Bulgarian",
                            "Slovak",
                            "Croatian",
                            "Serbian",
                            "Lithuanian",
                            "Latvian",
                            "Estonian",
                            "Persian",
                            "Urdu",
                            "Bengali",
                            "Tamil",
                            "Telugu",
                            "Malay",
                            "Filipino",
                            "Swahili",
                            "Afrikaans",
                            "Catalan"
                        ],
                        "type": "string",
                        "description": "Language Google should use for the search results (equivalent to Google's lr parameter).",
                        "default": "English"
                    },
                    "country": {
                        "title": "📍 Search from country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Netherlands",
                            "Poland",
                            "Russia",
                            "Ukraine",
                            "Brazil",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "Japan",
                            "South Korea",
                            "China",
                            "India",
                            "Indonesia",
                            "Thailand",
                            "Vietnam",
                            "Philippines",
                            "Malaysia",
                            "Singapore",
                            "Turkey",
                            "Israel",
                            "Saudi Arabia",
                            "United Arab Emirates",
                            "Egypt",
                            "South Africa",
                            "Nigeria",
                            "Kenya",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Belgium",
                            "Austria",
                            "Switzerland",
                            "Portugal",
                            "Greece",
                            "Czechia",
                            "Romania",
                            "Hungary",
                            "New Zealand",
                            "Moldova"
                        ],
                        "type": "string",
                        "description": "Country Google should treat the search as coming from (equivalent to Google's gl parameter). Affects result localization.",
                        "default": "United States"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
