# Track Google Search AI mentions of your brand and competitors (`netm8_solutions/google-aio-brand-tracker`) Actor

Track whether Google AI Overview mentions your brand, cites your domain, or gives visibility to competitors. Returns one JSON row per query with answer text, citation URLs, brand and competitor matches, share of voice, and optional organic results.

- **URL**: https://apify.com/netm8\_solutions/google-aio-brand-tracker.md
- **Developed by:** [netM8 Solutions](https://apify.com/netm8_solutions) (community)
- **Categories:** AI, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 query checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 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:

```json
{
  "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:

```bash
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:

```bash
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:

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

#### JavaScript and TypeScript

```ts
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

```py
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:

```handlebars
: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:

```text
/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:

```json
{
  "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.

# Actor input Schema

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

Search queries to check (1–500). Question-style and commercial queries trigger AI Overviews most often.

## `targetBrand` (type: `string`):

Brand to detect in the AI Overview answer text (e.g. "HubSpot"). Enables brand-match analysis.

## `targetDomain` (type: `string`):

Domain to detect among cited sources (e.g. "hubspot.com"). Enables citation matching.

## `brandAliases` (type: `array`):

Alternative names counted as mentions of the target brand.

## `competitors` (type: `array`):

Up to 10 competitor brand names (optionally "Name|domain.com") for share-of-voice comparison.

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

Google gl parameter (2-letter country code).

## `languageCode` (type: `string`):

Google hl parameter.

## `includeOrganicResults` (type: `boolean`):

Also extract top-10 organic results per query (no extra charge in v1).

## `maxRetries` (type: `integer`):

How many times a failed query is retried from a fresh proxy session before being marked failed (failed queries are never charged).

## `maxConcurrency` (type: `integer`):

How many queries are checked in parallel.

## `debugHtml` (type: `boolean`):

Stores fetched SERP HTML in the key-value store (for troubleshooting).

## Actor input object example

```json
{
  "queries": [
    "best crm for small business",
    "how to remove water stains from wood"
  ],
  "countryCode": "us",
  "languageCode": "en",
  "includeOrganicResults": false,
  "maxRetries": 3,
  "maxConcurrency": 5,
  "debugHtml": false
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `debugFiles` (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": [
        "best crm for small business",
        "how to remove water stains from wood"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("netm8_solutions/google-aio-brand-tracker").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": [
        "best crm for small business",
        "how to remove water stains from wood",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("netm8_solutions/google-aio-brand-tracker").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": [
    "best crm for small business",
    "how to remove water stains from wood"
  ]
}' |
apify call netm8_solutions/google-aio-brand-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Track Google Search AI mentions of your brand and competitors",
        "description": "Track whether Google AI Overview mentions your brand, cites your domain, or gives visibility to competitors. Returns one JSON row per query with answer text, citation URLs, brand and competitor matches, share of voice, and optional organic results.",
        "version": "0.1",
        "x-build-id": "2ujh08se535imh1A1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/netm8_solutions~google-aio-brand-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-netm8_solutions-google-aio-brand-tracker",
                "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/netm8_solutions~google-aio-brand-tracker/runs": {
            "post": {
                "operationId": "runs-sync-netm8_solutions-google-aio-brand-tracker",
                "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/netm8_solutions~google-aio-brand-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-netm8_solutions-google-aio-brand-tracker",
                "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": "Queries",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Search queries to check (1–500). Question-style and commercial queries trigger AI Overviews most often.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "targetBrand": {
                        "title": "Target brand name",
                        "type": "string",
                        "description": "Brand to detect in the AI Overview answer text (e.g. \"HubSpot\"). Enables brand-match analysis."
                    },
                    "targetDomain": {
                        "title": "Target domain",
                        "type": "string",
                        "description": "Domain to detect among cited sources (e.g. \"hubspot.com\"). Enables citation matching."
                    },
                    "brandAliases": {
                        "title": "Brand aliases",
                        "type": "array",
                        "description": "Alternative names counted as mentions of the target brand.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitors": {
                        "title": "Competitors",
                        "maxItems": 10,
                        "type": "array",
                        "description": "Up to 10 competitor brand names (optionally \"Name|domain.com\") for share-of-voice comparison.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryCode": {
                        "title": "Country",
                        "type": "string",
                        "description": "Google gl parameter (2-letter country code).",
                        "default": "us"
                    },
                    "languageCode": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google hl parameter.",
                        "default": "en"
                    },
                    "includeOrganicResults": {
                        "title": "Include top organic results",
                        "type": "boolean",
                        "description": "Also extract top-10 organic results per query (no extra charge in v1).",
                        "default": false
                    },
                    "maxRetries": {
                        "title": "Max retries per query",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times a failed query is retried from a fresh proxy session before being marked failed (failed queries are never charged).",
                        "default": 3
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many queries are checked in parallel.",
                        "default": 5
                    },
                    "debugHtml": {
                        "title": "Debug: store raw HTML",
                        "type": "boolean",
                        "description": "Stores fetched SERP HTML in the key-value store (for troubleshooting).",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```