Google AI Overview Brand Tracker and AEO API

Track whether Google AI Overview mentions your brand, cites your domain, or gives visibility to competitors.

This Actor runs up to 500 Google searches, detects AI Overview blocks, extracts the answer text and citations, and checks your target brand, domain, aliases, and competitors. Use the dataset for AEO/GEO audits, AI search visibility dashboards, weekly client reports, and automated brand monitoring.

What a check returns

	Example: "best crm for small business"
AI Overview	Present
Answer text	Full AI Overview text
Cited sources	Position, title, URL, and domain
Brand match	Mentioned in answer, cited as source, citation positions
Competitor match	Mention and citation checks for each competitor
Share of voice	Target brand and competitor visibility in one row

Each query creates one structured dataset row, ready for dashboards, CSV/Excel exports, slide decks, and downstream workflows.

Built for monitoring

• 1 to 500 queries per run.
• Target brand, target domain, and brand aliases.
• Up to 10 competitors, with optional Name|domain.com matching.
• Google country and language controls with countryCode and languageCode.
• Optional top organic results with includeOrganicResults.
• Failed checks are marked failed and are not charged by this Actor.
• Works through Apify Console, REST API, JS/Python clients, MCP, Slack, Sheets, and workflow tools.

Quick start

1. Add your search queries.
2. Set targetBrand and targetDomain.
3. Add competitors as "Name|domain.com" when you want share-of-voice comparison.
4. Schedule recurring runs and watch brandMatch.citedAsSource, brandMatch.mentionedInText, and shareOfVoice.

Connect this Actor

Use this Actor from chat clients, workflow builders, spreadsheets, or your own app. Each run writes structured rows to the default dataset, so most integrations follow the same pattern: run the Actor, wait for it to finish, then read defaultDatasetId.

Claude Desktop, ChatGPT, Cursor, VS Code, and Codex

Connect through the Apify MCP server and expose this Actor as a tool:

https://mcp.apify.com/?tools=actors,docs,experimental,runs,storage,netm8_solutions-owner/google-aio-brand-tracker

Use OAuth when your client supports remote MCP. After authorization, ask your assistant to run netm8_solutions-owner/google-aio-brand-tracker with input like this:

{
  "queries": ["best crm for small business"],
  "targetBrand": "HubSpot",
  "targetDomain": "hubspot.com",
  "competitors": ["Salesforce|salesforce.com", "Pipedrive|pipedrive.com"],
  "countryCode": "us",
  "languageCode": "en"
}

ChatGPT note: ChatGPT locks the selected MCP tools when you create a connector. Create a new connector if you change the tool list.

REST API

Use the synchronous endpoint for small batches that finish within 5 minutes:

curl -X POST \
  "https://api.apify.com/v2/actors/netm8_solutions-owner~google-aio-brand-tracker/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["best crm for small business"],
    "targetBrand": "HubSpot",
    "targetDomain": "hubspot.com",
    "competitors": ["Salesforce|salesforce.com", "Pipedrive|pipedrive.com"],
    "countryCode": "us",
    "languageCode": "en",
    "includeOrganicResults": false
  }'

For larger batches, start a run and read results after it finishes:

curl -X POST \
  "https://api.apify.com/v2/actors/netm8_solutions-owner~google-aio-brand-tracker/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["best crm for small business"],"targetBrand":"HubSpot","targetDomain":"hubspot.com"}'

The run response includes defaultDatasetId. Fetch results with:

curl \
  "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true" \
  -H "Authorization: Bearer $APIFY_TOKEN"

JavaScript and TypeScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('netm8_solutions-owner/google-aio-brand-tracker').call({
  queries: ['best crm for small business'],
  targetBrand: 'HubSpot',
  targetDomain: 'hubspot.com',
  competitors: ['Salesforce|salesforce.com', 'Pipedrive|pipedrive.com'],
  countryCode: 'us',
  languageCode: 'en',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems({ clean: true });
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(token=os.environ["APIFY_TOKEN"])

run = client.actor("netm8_solutions-owner/google-aio-brand-tracker").call(
    run_input={
        "queries": ["best crm for small business"],
        "targetBrand": "HubSpot",
        "targetDomain": "hubspot.com",
        "competitors": ["Salesforce|salesforce.com", "Pipedrive|pipedrive.com"],
        "countryCode": "us",
        "languageCode": "en",
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items(clean=True).items
print(items)

Saved tasks and schedules

Create a task when you run the same query set on a schedule:

1. Open the Actor in Apify Console.
2. Fill the input and choose Create a task.
3. Add a schedule, for example 0 6 * * 1 for Monday morning monitoring.
4. Use the task in Zapier, Make, n8n, Gumloop, Workato, IFTTT, or the API.

Saved tasks make downstream workflows easier because the integration only needs a task ID and optional input overrides.

Slack alerts

Open the Actor or task Integrations tab, choose Slack, select run events, and pick a channel. Use this message template for failed checks:

:warning: *AIO tracker run failed*
Run: <https://console.apify.com/actors/runs/{{resource.id}}|{{resource.id}}>
Status: `{{resource.status}}`
{{#if resource.statusMessage}}Reason: {{resource.statusMessage}}{{/if}}

After Slack is connected, you can also run saved no-input tasks from Slack:

/apify call ACTOR_OR_TASK_ID

HTTP webhooks

Use webhooks when another system needs to react to a run finishing. Configure the Actor or task Integrations tab, or create a webhook with the API.

Common event types:

• ACTOR.RUN.SUCCEEDED
• ACTOR.RUN.FAILED
• ACTOR.RUN.TIMED_OUT
• ACTOR.RUN.ABORTED

Recommended payload:

{
  "eventType": "{{eventType}}",
  "runId": "{{resource.id}}",
  "status": "{{resource.status}}",
  "datasetId": "{{resource.defaultDatasetId}}",
  "keyValueStoreId": "{{resource.defaultKeyValueStoreId}}"
}

Your endpoint should return a 2xx response within 30 seconds. Add a secret token or signed header, and make the receiver idempotent because webhook delivery can retry.

Google Sheets

For no-code exports, connect this Actor to the free lukaskrivka/google-sheets Actor.

Recommended setup:

1. Run this Actor.
2. Add an Actor-to-Actor integration that starts lukaskrivka/google-sheets on ACTOR.RUN.SUCCEEDED.
3. Pass the tracker run dataset into the Sheets Actor as datasetId.
4. Choose append for ongoing monitoring or replace for a fresh report table.

Make and n8n can also write tracker results to Google Sheets: run the Actor, get dataset items from defaultDatasetId, then map fields to spreadsheet columns.

Microsoft 365 and Excel

Use one of these routes:

• Export the Apify dataset as CSV or XLSX from Apify Console.
• Use Zapier, Make, n8n, Pipedream, or Workato to send dataset rows to Excel, SharePoint, Teams, or Outlook.
• Use a Microsoft Entra MCP connector when an Actor needs to call Microsoft tools through a user-authorized connection.
• Use an Excel MCP Actor for file-level spreadsheet reads, writes, and transformations.

Workflow builders

Popular workflow tools support the same building blocks:

• Zapier: run Actors or tasks, trigger on finished runs, fetch dataset items, and route rows to Slack, Google Sheets, CRMs, or email.
• Make: run the Actor synchronously for small jobs, or watch finished runs and write rows to Google Sheets.
• n8n: install the Apify community node, run the Actor, fetch dataset items, and pass them into AI, database, spreadsheet, or HTTP nodes.
• Pipedream: use Apify as a trigger or action, then process dataset rows in developer workflows.
• Activepieces, IFTTT, Gumloop, and Workato: connect with an Apify API token or OAuth, run tasks, and route outputs to downstream apps.

For long-running or large query batches, start the run asynchronously and let the workflow continue from a finished-run trigger.