# AI Visibility Tracker - Brand & Citation GEO (`khadinakbar/ai-visibility-tracker`) Actor

Track brand mentions and domain citations across Perplexity, ChatGPT, Gemini, and optional Claude. Returns one row per prompt x platform with share of voice, sentiment, cited URLs, source domains, and GEO recommendations. Use for SEO/GEO agencies and brand teams; not for website crawlability audits.

- **URL**: https://apify.com/khadinakbar/ai-visibility-tracker.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, SEO tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 ai visibility checks

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## AI Visibility Tracker - Brand Mentions, Citations & GEO Score

AI Visibility Tracker checks whether AI answer engines mention your brand and cite your website when buyers ask category questions. It submits bounded prompts to Perplexity, ChatGPT, Gemini, and optional Claude, then returns one record per prompt x platform with mention, citation, sentiment, share-of-voice, and source-domain signals for GEO and AEO reporting.

Use it when you need a fast brand visibility audit across AI search answers. Do not use it for website crawlability-only audits, raw Google AI Overview scraping, or domain citation tracking without a brand context; the related actors below are better fits for those narrower jobs.

### Output Fields

| Field | Description |
| --- | --- |
| `platform` | AI answer engine checked: Perplexity, ChatGPT, Gemini, or Claude |
| `query` | Exact prompt submitted to the AI platform |
| `brandMentioned` | Whether the tracked brand appeared in the answer |
| `brandPosition` | Approximate mention position from 1 early to 10 late |
| `brandShareOfVoice` | Brand mentions divided by brand plus competitor mentions |
| `sentiment` | Positive, neutral, or negative mention-context heuristic |
| `domainCited` | Whether the target domain was cited as a source |
| `citedUrls` | Source URLs extracted from citations, annotations, grounding, or links |
| `sourceDomains` | Deduplicated domains cited by the AI response |
| `competitorMentions` | Input competitors found in the answer |
| `aiAnswerExcerpt` | Concise or detailed response excerpt for review |

### Pricing

This actor uses Pay per event + usage. Event charges are `$0.10` per successful AI visibility check, where one check is one prompt on one AI platform. Apify platform usage is charged separately by Apify.

| Example run | Event charges |
| --- | ---: |
| 1 prompt x 1 platform | `$0.10` |
| 3 prompts x 3 default platforms | `$0.90` |
| 5 prompts x 4 platforms including Claude | `$2.00` |

The actor prints the maximum event-charge cap before it calls any AI provider. Failed provider calls are not billed as visibility-check rows.

### Input

```json
{
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools",
  "competitors": ["Bright Data", "Octoparse"],
  "queryTemplates": ["recommendations", "alternatives", "category_leaders"],
  "platforms": ["perplexity", "chatgpt", "gemini"],
  "maxQueries": 3,
  "responseFormat": "concise"
}
````

`brandName` is required. `targetDomain` is optional but recommended because it enables citation-rate and source-domain analysis. Claude is available when selected explicitly; it is not part of the default platform set to keep typical runs under agent-payment budgets.

### Output Example

```json
{
  "platform": "perplexity",
  "query": "Which web scraping tools should I consider, and is Apify a good option?",
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "brandMentioned": true,
  "brandMentionCount": 2,
  "brandPosition": 1,
  "brandShareOfVoice": 0.5,
  "sentiment": "positive",
  "domainCited": true,
  "citedUrl": "https://apify.com/store",
  "citedUrls": ["https://apify.com/store"],
  "sourceDomains": ["apify.com"],
  "competitorMentions": ["Bright Data"],
  "competitorMentionCount": 2,
  "modelUsed": "perplexity/sonar",
  "checkedAt": "2026-07-14T18:00:00.000Z"
}
```

Compact `OUTPUT` and detailed `RUN_SUMMARY` records are also written to the key-value store. The summary includes GEO score, platform scores, top source domains, top competitors, provider diagnostics, event charges, and recommendations.

### API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~ai-visibility-tracker/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "brandName": "Apify",
    "targetDomain": "apify.com",
    "industry": "web scraping tools",
    "competitors": ["Bright Data", "Octoparse"],
    "platforms": ["perplexity", "chatgpt", "gemini"],
    "maxQueries": 3
  }'
```

### MCP And Agent Use

Through the Apify MCP Server, this actor is useful for questions like:

- "Check whether Apify is mentioned by AI search engines for web scraping tool prompts."
- "Compare my brand's AI share of voice against these competitors."
- "Which source domains do AI answers cite when discussing my category?"

The actor returns a flat, schema-declared dataset so agents can page results, filter by platform, and summarize the `RUN_SUMMARY` KV record.

### Limits And Reliability Notes

AI answer engines change outputs frequently. Treat each run as a dated sample, not a permanent ranking or citation guarantee. The actor records the model used and `checkedAt` timestamp so recurring runs can be compared over time.

Provider calls require owner-managed `OPENROUTER_API_KEY`; native Gemini uses `GEMINI_API_KEY` when available and falls back to OpenRouter Gemini online when possible. If a required provider is unavailable and no useful rows are produced, the actor fails honestly with `UPSTREAM_FAILED` or `CONFIG_ERROR` and writes `OUTPUT` plus `RUN_SUMMARY`.

### Related Actors

Use [AI Search Brand Monitor](https://apify.com/khadinakbar/ai-search-brand-monitor) when you want the older brand-monitoring contract focused on brand mention trends and GEO recommendations.

Use [AI Search Visibility Tracker](https://apify.com/khadinakbar/ai-search-visibility-tracker) when the job is domain citation tracking for topic keywords and the brand name itself is secondary.

Use [AI Overviews Tracker](https://apify.com/khadinakbar/ai-overviews-tracker) when the target is Google AI Overview-specific visibility rather than multi-engine AI answers.

### Legal And Data Use

This actor queries AI provider APIs and records generated answer excerpts, citation URLs, and derived visibility metrics. Review provider terms and your organization's policies before using outputs in public reports. Do not submit private customer data, secrets, or personal information in prompts.

# Actor input Schema

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

Use this when you want to track one brand, company, product, or tool in AI answers. Enter the public name exactly as customers write it, for example "Apify". Required for every real scan and prefilled for testing. Not a competitor list; put rivals in competitors.

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

Use this when you also want citation tracking for the brand website. Enter a bare domain such as "apify.com" or a URL like "https://apify.com". Defaults to blank, which skips owned-domain citation checks but still tracks brand mentions. Not a list of pages.

## `industry` (type: `string`):

Use this when built-in prompts should include the market category. Enter a short phrase such as "web scraping tools" or "CRM software". Defaults to "software tools" when blank. Not a keyword list; use queries for exact prompts.

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

Use this when you want share-of-voice against specific rivals. Enter brand names or domains, for example \["Bright Data", "Octoparse"]. Defaults to an empty list and accepts up to 10 values. Not the tracked brand; use brandName for that.

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

Use this when you have exact customer questions to test. Enter one prompt per line, for example "What are the best web scraping tools?". Defaults to empty, so the actor generates prompts from queryTemplates. Not search keywords; these are full questions sent to AI platforms.

## `queryTemplates` (type: `array`):

Use this when you want standard buyer-intent prompt categories. Defaults to recommendations, alternatives, and category\_leaders. Choose from the listed values; each selected template may create multiple prompts before maxQueries caps the run. Not used to rewrite custom queries.

## `platforms` (type: `array`):

Use this to choose which AI answer engines to check. Defaults to \["perplexity", "chatgpt", "gemini"] for bounded cost. Add "claude" only when you explicitly need a deeper audit; Claude is token-capped. Not a model-id field.

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

Use this to cap the number of unique prompts before multiplying by selected platforms. Defaults to 3, so the normal 3-platform run costs about $0.90 in event charges. Minimum 1 and maximum 10. Not the dataset item cap; each prompt x platform can create one row.

## `responseFormat` (type: `string`):

Use this to control how much AI-answer text is stored in each row. Defaults to "concise" for MCP and agent workflows. Choose "detailed" when a human will inspect answer context. Not a platform selector.

## `webhookUrl` (type: `string`):

Use this when another system should receive the run summary after completion. Enter an HTTPS endpoint such as "https://hooks.zapier.com/hooks/catch/...". Defaults to blank, so no webhook is sent. Not used for authentication or API keys.

## `demoMode` (type: `boolean`):

Use this when you want a no-charge connectivity check. When true, the actor writes OUTPUT and RUN\_SUMMARY without calling AI providers. Defaults to false for real scans. Not a cached visibility report.

## Actor input object example

```json
{
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools",
  "competitors": [
    "Bright Data",
    "Octoparse"
  ],
  "queries": [
    "What are the best web scraping tools?",
    "Is Apify good for data extraction?"
  ],
  "queryTemplates": [
    "recommendations",
    "alternatives",
    "category_leaders"
  ],
  "platforms": [
    "perplexity",
    "chatgpt",
    "gemini"
  ],
  "maxQueries": 3,
  "responseFormat": "concise",
  "webhookUrl": "https://hooks.zapier.com/hooks/catch/123/abc",
  "demoMode": false
}
```

# Actor output Schema

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

Dataset items, one per successful prompt x platform check.

## `output` (type: `string`):

Stable compact machine-readable outcome contract.

## `runSummary` (type: `string`):

Detailed diagnostics, metrics, provider attempts, platform scores, recommendations, charges, and warnings.

# 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",
    "targetDomain": "apify.com",
    "industry": "web scraping tools"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/ai-visibility-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 = {
    "brandName": "Apify",
    "targetDomain": "apify.com",
    "industry": "web scraping tools",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/ai-visibility-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 '{
  "brandName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools"
}' |
apify call khadinakbar/ai-visibility-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Visibility Tracker - Brand & Citation GEO",
        "description": "Track brand mentions and domain citations across Perplexity, ChatGPT, Gemini, and optional Claude. Returns one row per prompt x platform with share of voice, sentiment, cited URLs, source domains, and GEO recommendations. Use for SEO/GEO agencies and brand teams; not for website crawlability audits.",
        "version": "1.0",
        "x-build-id": "n3uNmYdJb4veZVbyB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~ai-visibility-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-ai-visibility-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/khadinakbar~ai-visibility-tracker/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-ai-visibility-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/khadinakbar~ai-visibility-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-ai-visibility-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": [
                    "brandName"
                ],
                "properties": {
                    "brandName": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "Use this when you want to track one brand, company, product, or tool in AI answers. Enter the public name exactly as customers write it, for example \"Apify\". Required for every real scan and prefilled for testing. Not a competitor list; put rivals in competitors."
                    },
                    "targetDomain": {
                        "title": "Target domain",
                        "type": "string",
                        "description": "Use this when you also want citation tracking for the brand website. Enter a bare domain such as \"apify.com\" or a URL like \"https://apify.com\". Defaults to blank, which skips owned-domain citation checks but still tracks brand mentions. Not a list of pages.",
                        "default": ""
                    },
                    "industry": {
                        "title": "Industry or category",
                        "type": "string",
                        "description": "Use this when built-in prompts should include the market category. Enter a short phrase such as \"web scraping tools\" or \"CRM software\". Defaults to \"software tools\" when blank. Not a keyword list; use queries for exact prompts.",
                        "default": "software tools"
                    },
                    "competitors": {
                        "title": "Competitors",
                        "type": "array",
                        "description": "Use this when you want share-of-voice against specific rivals. Enter brand names or domains, for example [\"Bright Data\", \"Octoparse\"]. Defaults to an empty list and accepts up to 10 values. Not the tracked brand; use brandName for that.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "queries": {
                        "title": "Custom AI prompts",
                        "type": "array",
                        "description": "Use this when you have exact customer questions to test. Enter one prompt per line, for example \"What are the best web scraping tools?\". Defaults to empty, so the actor generates prompts from queryTemplates. Not search keywords; these are full questions sent to AI platforms.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "queryTemplates": {
                        "title": "Query templates",
                        "type": "array",
                        "description": "Use this when you want standard buyer-intent prompt categories. Defaults to recommendations, alternatives, and category_leaders. Choose from the listed values; each selected template may create multiple prompts before maxQueries caps the run. Not used to rewrite custom queries.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "recommendations",
                                "alternatives",
                                "category_leaders",
                                "reviews",
                                "comparisons"
                            ],
                            "enumTitles": [
                                "Recommendations",
                                "Alternatives",
                                "Category leaders",
                                "Reviews",
                                "Comparisons"
                            ]
                        },
                        "default": [
                            "recommendations",
                            "alternatives",
                            "category_leaders"
                        ]
                    },
                    "platforms": {
                        "title": "AI platforms",
                        "type": "array",
                        "description": "Use this to choose which AI answer engines to check. Defaults to [\"perplexity\", \"chatgpt\", \"gemini\"] for bounded cost. Add \"claude\" only when you explicitly need a deeper audit; Claude is token-capped. Not a model-id field.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "perplexity",
                                "chatgpt",
                                "gemini",
                                "claude"
                            ],
                            "enumTitles": [
                                "Perplexity",
                                "ChatGPT",
                                "Gemini",
                                "Claude"
                            ]
                        },
                        "default": [
                            "perplexity",
                            "chatgpt",
                            "gemini"
                        ]
                    },
                    "maxQueries": {
                        "title": "Max prompts to run",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Use this to cap the number of unique prompts before multiplying by selected platforms. Defaults to 3, so the normal 3-platform run costs about $0.90 in event charges. Minimum 1 and maximum 10. Not the dataset item cap; each prompt x platform can create one row.",
                        "default": 3
                    },
                    "responseFormat": {
                        "title": "Response format",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use this to control how much AI-answer text is stored in each row. Defaults to \"concise\" for MCP and agent workflows. Choose \"detailed\" when a human will inspect answer context. Not a platform selector.",
                        "default": "concise"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Use this when another system should receive the run summary after completion. Enter an HTTPS endpoint such as \"https://hooks.zapier.com/hooks/catch/...\". Defaults to blank, so no webhook is sent. Not used for authentication or API keys.",
                        "default": ""
                    },
                    "demoMode": {
                        "title": "Demo mode",
                        "type": "boolean",
                        "description": "Use this when you want a no-charge connectivity check. When true, the actor writes OUTPUT and RUN_SUMMARY without calling AI providers. Defaults to false for real scans. Not a cached visibility report.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
