# AI Brand Visibility Monitor - GEO & AI Search Tracker (`geneius/ai-brand-visibility-monitor`) Actor

Track brand mentions, competitor visibility, citations, GEO scores, and action items in AI-generated buyer answers through the Apify OpenRouter proxy.

- **URL**: https://apify.com/geneius/ai-brand-visibility-monitor.md
- **Developed by:** [Gene](https://apify.com/geneius) (community)
- **Categories:** AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

### AI Brand Visibility Monitor - GEO & AI Search Tracker

Track whether a brand appears in AI-generated buyer answers before your buyers ask the same questions.

This Actor runs high-intent prompts through OpenRouter-compatible models on Apify, then turns each answer into structured GEO/AEO signals: brand mention status, competitor mentions, citation URLs, visibility score, and the next content or positioning action.

Use it when an agency, SEO team, or B2B marketer needs recurring evidence for questions like:

- "Does this client appear when buyers ask for the best tools in the category?"
- "Which competitors are AI models recommending instead?"
- "Are our comparison pages, alternative pages, and citations showing up?"
- "What should we publish or fix next?"

Need a client-ready report after the checks finish? Run the companion [AI Visibility Report Generator](https://apify.com/geneius/ai-visibility-report-generator) on this Actor's dataset.

<!-- revenue-machine:workflow-hub:start -->
### Workflow Hub

See the public [AI visibility workflow](https://geneiusk.github.io/apify-actor-powerhouse-hub/ai-visibility.html) for the monitor -> report path, demo story, and links to both Actors. If you are monitoring a product's presence in AI answers, start with the [AI search visibility monitoring use case](https://geneiusk.github.io/apify-actor-powerhouse-hub/ai-search-visibility-monitoring.html). For the first proof run, use the [AI Brand Monitor demo script](https://geneiusk.github.io/apify-actor-powerhouse-hub/ai-brand-monitor-demo.html) and [proof GIF](https://geneiusk.github.io/apify-actor-powerhouse-hub/assets/ai-brand-monitor-proof.gif).
<!-- revenue-machine:workflow-hub:end -->

### What You Learn

- Whether your brand appears for high-intent AI search prompts
- Which competitors appear in the same answer
- Whether the answer includes your canonical domain or citation URLs
- How prominently the brand appears compared with alternatives
- What content or positioning action to take next

### Use Cases

- GEO/AEO monitoring for agencies and consultants
- AI search visibility tracking for brand and content teams
- Generative engine optimization reporting for high-intent buyer prompts
- Weekly brand visibility checks for B2B SaaS teams
- Competitor comparison monitoring across AI answer models
- Client-ready exports for recurring SEO and content reports
- Early warning when competitors start appearing in high-intent AI answers

### Weekly Workflow

1. Pick 5-50 buyer-intent queries for a brand or client.
2. Run this Actor weekly using the same prompt set and competitor list.
3. Review the dataset for low scores, missing brand mentions, competitor appearances, and citation gaps.
4. Send the dataset to [AI Visibility Report Generator](https://apify.com/geneius/ai-visibility-report-generator) to create a client-ready summary and action plan.
5. Track score movement over time in Sheets, Slack, a CRM, or an internal reporting dashboard.

### Input

Required:

- `brandName`: Brand or product name to monitor.
- `queries`: Buyer questions to ask the AI model.

Recommended:

- `brandWebsite`: Canonical website used to detect citation and domain mentions.
- `brandAliases`: Alternate names that should count as the brand.
- `competitors`: Competitor names to detect.
- `modelIds`: OpenRouter-compatible model IDs. The default is `openrouter/auto`.

Example:

```json
{
  "brandName": "Apify",
  "brandWebsite": "https://apify.com",
  "brandAliases": ["Apify Actors"],
  "competitors": ["Bright Data", "Oxylabs"],
  "queries": [
    "best web scraping platforms for developers",
    "best tools to extract web data at scale"
  ],
  "modelIds": ["openrouter/auto"],
  "maxQueries": 2,
  "maxModels": 1,
  "maxAnswerTokens": 500
}
````

### Output

Each dataset item represents one brand-query-model check:

```json
{
  "status": "succeeded",
  "brandName": "Apify",
  "query": "best web scraping platforms for developers",
  "modelId": "openrouter/auto",
  "provider": "apify-openrouter",
  "brandMentioned": true,
  "brandPosition": 1,
  "competitorsMentioned": ["Bright Data"],
  "brandDomainMentioned": true,
  "citationUrls": ["https://apify.com"],
  "visibilityScore": 95,
  "recommendation": "Apify appears prominently. Maintain freshness and monitor competitor movement.",
  "checkedAt": "2026-05-11T17:30:00+00:00"
}
```

The run also writes a `SUMMARY` key-value-store record with counts, models, provider, and the charge event name.

### Demo Analysis

Example agency-client result:

```json
{
  "brandName": "Northstar CRM",
  "query": "best CRM for B2B SaaS teams tracking product-led sales",
  "brandMentioned": false,
  "brandPosition": null,
  "competitorsMentioned": ["HubSpot", "Salesforce", "Pipedrive"],
  "brandDomainMentioned": false,
  "citationUrls": [],
  "visibilityScore": 5,
  "recommendation": "Northstar CRM is absent while HubSpot, Pipedrive, Salesforce appear. Publish comparison, alternatives, and buyer-intent pages that answer this query directly."
}
```

This real cloud demo run shows the core workflow: run a buyer query, detect when known competitors appear but the monitored brand is absent, and turn the gap into a concrete content or positioning action. The Actor package includes three public-safe demo inputs and real cloud output snapshots in the `examples/` folder.

### Companion Report Generator

For agency reporting, use this Actor as the data collection step and [AI Visibility Report Generator](https://apify.com/geneius/ai-visibility-report-generator) as the reporting step.

The report generator consumes this Actor's dataset and produces:

- Executive summary
- Average visibility score
- Brand mention rate
- Citation rate
- Top competitors
- Priority query gaps
- Recommended next actions
- `REPORT.md` in the key-value store

### Pricing

Default monetization model: pay per event.

Recommended chargeable event:

- Event name: `brand-query-model-check`
- Event meaning: one completed brand-query-model visibility check
- Store price: `$0.08` per completed check
- Pricing activation: scheduled for `2026-05-26T17:18:05Z`

The Actor uses the Apify OpenRouter proxy, which is billed as platform usage through Apify. Successful rows are pushed only after the charge path allows the event, and a paid smoke should run after the scheduled activation time.

### FAQ

#### Does this check real AI answers?

Yes. It sends your buyer-intent prompts through OpenRouter-compatible models on Apify and analyzes the returned answers for brand mentions, competitor mentions, citations, and next actions.

#### Does it log in to ChatGPT, Claude, Gemini, or Perplexity?

No. It uses the Apify OpenRouter proxy, not logged-in consumer AI product sessions. That keeps the workflow easier to schedule and avoids credential handling.

#### What should I use for the first run?

Start with 2-5 buyer questions, one brand name, the canonical website, and 2-5 competitors. The Store example is public-safe and can be pasted directly.

#### What do I get back?

Each dataset item is one brand-query-model check with a visibility score, competitor mentions, citation URLs, and a recommendation. The run also writes a `SUMMARY` record for reporting.

#### When is it commercially chargeable?

The configured paid event is `brand-query-model-check` at `$0.08`, scheduled for 2026-05-26T17:18:05Z. Run a small paid smoke after activation before promoting high-volume use.

### Limitations

- Results depend on the selected model and the OpenRouter proxy response.
- The Actor checks AI model answers, not every consumer AI product UI.
- Citation detection is text based. If a model omits URLs, the Actor can still score name visibility but cannot prove citation visibility.
- This Actor does not scrape logged-in ChatGPT, Claude, Gemini, or Perplexity sessions.

### Automation And Agent Use

The Actor is designed for scheduled workflows and agent tools:

- One dataset item equals one brand-query-model check.
- `visibilityScore`, `brandMentioned`, `competitorsMentioned`, `citationUrls`, and `recommendation` are stable fields for downstream summaries.
- The `SUMMARY` key-value-store record includes run-level counts, selected models, provider, and billing event name.
- For weekly reports, send the default dataset to Google Sheets, Slack, a CRM, or an internal dashboard.

### Local Development

```bash
python3 -m pip install -r requirements.txt
ACTOR_TEST_PAY_PER_EVENT=true APIFY_TOKEN=your_token_here apify run --purge --input-file examples/smoke-input.json
```

The committed smoke input lives in `examples/smoke-input.json`.

If the Apify OpenRouter proxy returns `access_denied` from a local run, validate with a cloud run. Apify's AI-agent documentation notes that free-tier accounts may be blocked by anti-fraud protections for OpenRouter access, while the same Actor can still work in the Apify runtime.

### Store Positioning

Title:

AI Brand Visibility Monitor - GEO & AI Search Tracker

SEO description:

Track brand mentions, competitor visibility, citations, GEO scores, and action items in AI-generated buyer answers using OpenRouter-compatible models on Apify.

Categories:

- AI
- Marketing
- SEO
- Business intelligence

Search keywords:

- AI brand visibility monitor
- GEO tracker
- AI search visibility
- generative engine optimization
- AI answer monitoring

# Actor input Schema

## `brandName` (type: `string`):

The exact brand or product name to monitor in AI answers.

## `brandWebsite` (type: `string`):

Optional canonical brand website. The domain is used to detect citation and URL mentions.

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

Optional alternate spellings, product names, or abbreviations that should count as brand mentions.

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

Competitor names to detect in the AI answer.

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

Search or buying questions to ask the AI model. Each query becomes one check for each selected model.

## `modelIds` (type: `array`):

OpenRouter-compatible model IDs routed through the Apify OpenRouter proxy. Use openrouter/auto for the broad default.

## `maxQueries` (type: `integer`):

Safety cap for buyer queries processed in a single run.

## `maxModels` (type: `integer`):

Safety cap for model IDs processed in a single run.

## `maxAnswerTokens` (type: `integer`):

Maximum tokens requested from each AI answer.

## `temperaturePercent` (type: `integer`):

Temperature as a whole percent. 20 means temperature 0.20.

## `includeRawAnswer` (type: `boolean`):

When enabled, dataset items include the full AI answer. Disable for lighter exports.

## `failOnProviderError` (type: `boolean`):

When enabled, the run fails after the first OpenRouter error instead of returning partial error records.

## Actor input object example

```json
{
  "brandName": "Apify",
  "brandWebsite": "https://apify.com",
  "brandAliases": [],
  "competitors": [
    "Bright Data",
    "Oxylabs"
  ],
  "queries": [
    "best web scraping platforms for developers",
    "best tools to extract web data at scale"
  ],
  "modelIds": [
    "openrouter/auto"
  ],
  "maxQueries": 10,
  "maxModels": 3,
  "maxAnswerTokens": 700,
  "temperaturePercent": 20,
  "includeRawAnswer": true,
  "failOnProviderError": false
}
```

# Actor output Schema

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

Dataset items with one row per brand-query-model check, including visibility score, mentions, citations, competitors, and recommendations.

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

Run-level summary with counts, charge event name, and stop status.

# 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 = {
    "brandName": "Apify",
    "brandWebsite": "https://apify.com",
    "brandAliases": [],
    "competitors": [
        "Bright Data",
        "Oxylabs"
    ],
    "queries": [
        "best web scraping platforms for developers",
        "best tools to extract web data at scale"
    ],
    "modelIds": [
        "openrouter/auto"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("geneius/ai-brand-visibility-monitor").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 = {
    "brandName": "Apify",
    "brandWebsite": "https://apify.com",
    "brandAliases": [],
    "competitors": [
        "Bright Data",
        "Oxylabs",
    ],
    "queries": [
        "best web scraping platforms for developers",
        "best tools to extract web data at scale",
    ],
    "modelIds": ["openrouter/auto"],
}

# Run the Actor and wait for it to finish
run = client.actor("geneius/ai-brand-visibility-monitor").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 '{
  "brandName": "Apify",
  "brandWebsite": "https://apify.com",
  "brandAliases": [],
  "competitors": [
    "Bright Data",
    "Oxylabs"
  ],
  "queries": [
    "best web scraping platforms for developers",
    "best tools to extract web data at scale"
  ],
  "modelIds": [
    "openrouter/auto"
  ]
}' |
apify call geneius/ai-brand-visibility-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Brand Visibility Monitor - GEO & AI Search Tracker",
        "description": "Track brand mentions, competitor visibility, citations, GEO scores, and action items in AI-generated buyer answers through the Apify OpenRouter proxy.",
        "version": "0.1",
        "x-build-id": "ldoc7asgg0N6jDw5m"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/geneius~ai-brand-visibility-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-geneius-ai-brand-visibility-monitor",
                "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/geneius~ai-brand-visibility-monitor/runs": {
            "post": {
                "operationId": "runs-sync-geneius-ai-brand-visibility-monitor",
                "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/geneius~ai-brand-visibility-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-geneius-ai-brand-visibility-monitor",
                "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": [
                    "brandName",
                    "queries"
                ],
                "properties": {
                    "brandName": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "The exact brand or product name to monitor in AI answers."
                    },
                    "brandWebsite": {
                        "title": "Brand website",
                        "type": "string",
                        "description": "Optional canonical brand website. The domain is used to detect citation and URL mentions."
                    },
                    "brandAliases": {
                        "title": "Brand aliases",
                        "type": "array",
                        "description": "Optional alternate spellings, product names, or abbreviations that should count as brand mentions.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitors": {
                        "title": "Competitors",
                        "type": "array",
                        "description": "Competitor names to detect in the AI answer.",
                        "default": [
                            "Bright Data",
                            "Oxylabs"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Buyer queries",
                        "type": "array",
                        "description": "Search or buying questions to ask the AI model. Each query becomes one check for each selected model.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "modelIds": {
                        "title": "OpenRouter model IDs",
                        "type": "array",
                        "description": "OpenRouter-compatible model IDs routed through the Apify OpenRouter proxy. Use openrouter/auto for the broad default.",
                        "default": [
                            "openrouter/auto"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxQueries": {
                        "title": "Maximum queries",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for buyer queries processed in a single run.",
                        "default": 10
                    },
                    "maxModels": {
                        "title": "Maximum models",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Safety cap for model IDs processed in a single run.",
                        "default": 3
                    },
                    "maxAnswerTokens": {
                        "title": "Maximum answer tokens",
                        "minimum": 100,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum tokens requested from each AI answer.",
                        "default": 700
                    },
                    "temperaturePercent": {
                        "title": "Temperature percent",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Temperature as a whole percent. 20 means temperature 0.20.",
                        "default": 20
                    },
                    "includeRawAnswer": {
                        "title": "Include raw answer",
                        "type": "boolean",
                        "description": "When enabled, dataset items include the full AI answer. Disable for lighter exports.",
                        "default": true
                    },
                    "failOnProviderError": {
                        "title": "Fail on provider error",
                        "type": "boolean",
                        "description": "When enabled, the run fails after the first OpenRouter error instead of returning partial error records.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```