# AI Visibility Checker — ChatGPT, Gemini & AI Overviews (`wheaten_steelpan/ai-visibility-checker`) Actor

Track how often ChatGPT, Gemini, Perplexity, Claude & Google AI Overviews mention and cite your brand versus competitors. GEO/AEO monitoring with visibility score, share of voice, cited sources and a forwardable HTML report.

- **URL**: https://apify.com/wheaten\_steelpan/ai-visibility-checker.md
- **Developed by:** [Vanja V](https://apify.com/wheaten_steelpan) (community)
- **Categories:** AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 prompt checks

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

## AI Visibility Checker — track your brand in ChatGPT, Gemini, Perplexity, Claude & Google AI Overviews

Your customers are asking AI for recommendations. **Is your brand in the answers?**

This actor checks how often AI answer engines mention and cite your brand — versus your competitors — for the buyer-intent questions that matter to you. It's the data layer for **GEO / AEO (Generative Engine Optimization)**: the same insight dedicated SaaS visibility tools sell for $99–500/month, priced per check instead.

### What you get

For every prompt × platform combination:

- ✅ Was your brand **mentioned**? At what **position** relative to other brands?
- 🔗 Which sources did the AI **cite** — and was your website among them?
- ⚔️ Which **competitors** were mentioned, and where?
- 📊 Aggregates: **visibility score (0–100)**, **share of voice**, citation rate, top cited domains
- 📄 A clean **HTML report** you can forward straight to a client or your team

### Supported AI platforms

| Platform | How it works | What you need |
|---|---|---|
| **Google AI Overviews** | Real Google search results | Nothing — works out of the box |
| **Gemini** | Gemini with Google Search grounding | Nothing — works out of the box (or bring your own free Google AI Studio key) |
| **ChatGPT** | OpenAI web-search-enabled models | Your OpenAI API key |
| **Perplexity** | Perplexity `sonar` (search-native) | Your Perplexity API key |
| **Claude** | Claude with web search | Your Anthropic API key |

Bring-your-own-key platforms run on **your** quota — your key is used only for your checks and never stored.

### Quick start

1. Enter your **brand name** and **domain** (e.g. `apify.com`).
2. Add 5–20 **prompts** — the questions your customers actually ask AI (*"best CRM for small agencies"*, not your brand name).
3. List your **competitors** (optionally with domain: `Zyte|zyte.com`).
4. Optionally set a **Country** (two-letter code like `de`) and **Language** to measure a specific market instead of the US/global default.
5. Pick platforms and hit **Start**. Read the dataset, the `SUMMARY`, and the `REPORT` (HTML) in the run's storage.

### Output

Each check becomes one dataset item:

```json
{
  "prompt": "best web scraping platform for developers",
  "platform": "gemini",
  "model": "gemini-2.5-flash",
  "checkedAt": "2026-07-11T12:30:00.000Z",
  "location": { "countryCode": "de", "language": "de" },
  "latencyMs": 4210,
  "brand": {
    "name": "Apify",
    "mentioned": true,
    "position": 1,
    "mentionCount": 3,
    "firstMentionSnippet": "…platforms like Apify offer…",
    "domainCited": true
  },
  "competitors": [
    { "name": "Zyte", "mentioned": true, "position": 2, "mentionCount": 1, "domainCited": false }
  ],
  "totalBrandsDetected": 4,
  "citedUrls": ["https://www.reddit.com/r/webscraping/…", "https://apify.com/…"],
  "citedDomains": ["reddit.com", "apify.com"],
  "citedSources": [{ "url": "https://www.reddit.com/r/webscraping/…", "domain": "reddit.com" }],
  "answerText": "…full answer for auditing…",
  "error": null
}
````

`location` appears when you set a country/language; failed checks keep the same shape with `error: { "message", "code" }` filled in, and Google AI Overviews items add `aiOverviewPresent`. The exact `model`, `checkedAt` and `latencyMs` on every item keep historical comparisons meaningful even as providers update their models. The key-value store holds `SUMMARY` (JSON aggregates) and `REPORT` (self-contained HTML).

### What a run costs

You pay a small start fee plus a fixed price per **completed** check (one prompt on one platform) — failed checks are never charged. So 10 prompts × 2 platforms = 20 checks; the exact per-event prices are listed in the pricing section of this page, and every run logs its estimated charge up front before the checks start.

In practice that means a typical monitoring setup — 20 prompts across 2 platforms, checked weekly — costs about **$9/month**. Track all 5 platforms weekly and it's still around $22/month, versus the $99–500/month that dedicated AI visibility SaaS tools charge for the same data. You can cap total spend with Apify's built-in **Maximum cost per run** setting. Bring-your-own-key platforms additionally use your own provider API quota (billed by that provider, not by us).

### Track trends with scheduled runs

AI answers change constantly — a single run is a snapshot. Create a **Schedule** in Apify Console (weekly works well), point it at this actor with your saved input, and compare visibility scores over time. That trend line is the real product.

### FAQ

**Is this the same as asking the ChatGPT / Gemini / Claude app directly?**
Close, but not identical — and we'd rather you know exactly what's measured. Checks run through each platform's **official API with web search or grounding enabled** (the same underlying answer engines), not through a logged-in consumer app. Consumer apps add personalization, account history, and regional experiments that no monitoring tool can fully reproduce. Treat the results as a strong proxy for what a typical signed-out user is told. For full auditability, every check records the exact model that answered (`model` field in the dataset, also shown in the report) plus the complete answer text.

**Why do results differ between runs?**
AI answers are non-deterministic and personalized: the same prompt can produce different answers minutes apart, and Google doesn't show an AI Overview for every query every time. That variance is real data — track trends across scheduled runs rather than reading a single snapshot as ground truth.

**Can I check visibility in a specific country or language?**
Yes. Set **Country** to a two-letter code (e.g. `de`, `gb`, `br`): Google AI Overviews then searches Google from that country, and ChatGPT, Perplexity and Claude localize their web search to it. Set **Language** to control the language of Google AI Overviews results. For the AI chat platforms the answer language follows your prompts, so write prompts in your target language. One honest caveat: the Gemini API doesn't support location targeting yet, so Gemini checks stay global. Leave both fields empty and everything behaves exactly as before (US/global).

**What prompts should I use?**
Questions with buying intent where you want to be recommended: "best X for Y", "X vs Y", "how to solve \[problem your product solves]". Avoid prompts containing your brand name — you're measuring unaided visibility.

**How is the visibility score calculated?**
Transparently: `visibilityScore = round(60 × mention rate + 25 × citation rate + 15 × position score)`, where *mention rate* is the share of successful checks that mention your brand, *citation rate* is the share where your domain is among the cited sources, and *position score* averages `1/position` over the checks where you're mentioned (1st brand mentioned = 1.0, 2nd = 0.5, …). Mentions weigh most because being in the answer is the battle; citations and early positioning refine it. The formula is versioned (`scoreVersion` in `SUMMARY`) — if the weighting ever changes, the version number changes with it, so trend lines stay honest.

**What does "mentioned" vs "cited" mean?**
*Mentioned* = your brand name appears in the answer text. *Cited* = your website is one of the sources the AI links to. They're different levers: mentions come from being part of the conversation (reviews, comparisons, communities); citations come from having content AI engines consider a source of truth.

**Is my API key safe?**
Key fields are marked secret in the input schema: Apify encrypts them at rest and they are decrypted only inside your actor run. The actor uses your key solely to call the provider you selected, during your run, and never writes it to logs, datasets, or reports. (To be precise: the actor code does receive the plaintext key at runtime — that's how any BYOK integration works — it just never persists it anywhere.)

# Actor input Schema

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

The brand to track in AI answers.

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

Alternative spellings or product names counted as brand mentions (e.g. 'HubSpot CRM' for 'HubSpot').

## `brandDomain` (type: `string`):

Your website domain, used to detect when AI answers cite your site (e.g. apify.com).

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

One competitor per line as Name|domain, e.g. 'Zyte|zyte.com'. The name is matched in answer text, the domain in cited sources. A name alone ('Zyte') or a bare domain ('zyte.com') also works.

## `prompts` (type: `array`):

Buyer-intent questions your customers ask AI. 5-20 recommended.

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

Which AI answer engines to check. Gemini and Google AI Overviews work out of the box. ChatGPT, Perplexity and Claude require your own API key below (your key, your quota — encrypted by Apify, used only inside your run to call that provider, never written to logs or results).

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

Two-letter country code (e.g. 'de', 'gb', 'br') to check visibility from that market. Google AI Overviews searches Google from that country; ChatGPT, Perplexity and Claude localize their web search to it. The Gemini API does not support location targeting yet, so Gemini checks are unaffected. Leave empty for the default (US/global) — existing setups behave exactly as before.

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

Language code (e.g. 'de', 'es', 'nl') for Google AI Overviews results. Tip: for the AI chat platforms (ChatGPT, Gemini, Perplexity, Claude) the answer language follows your prompts — write prompts in your target language. Leave empty for the default (English).

## `geminiApiKey` (type: `string`):

Bring your own Google AI Studio key to run Gemini checks on your own quota.

## `openaiApiKey` (type: `string`):

Create one at platform.openai.com/api-keys. Used only for your ChatGPT checks, on your own quota.

## `perplexityApiKey` (type: `string`):

Create one in your Perplexity account settings. Used only for your Perplexity checks, on your own quota.

## `anthropicApiKey` (type: `string`):

Create one at platform.claude.com. Used only for your Claude checks, on your own quota.

## Actor input object example

```json
{
  "brandName": "Notion",
  "brandAliases": [],
  "brandDomain": "notion.so",
  "competitors": [
    "Asana|asana.com",
    "ClickUp|clickup.com",
    "Trello|trello.com"
  ],
  "prompts": [
    "best note taking app for teams",
    "best project management tool for startups",
    "best all-in-one workspace app for remote work"
  ],
  "platforms": [
    "gemini",
    "googleAiOverviews"
  ]
}
```

# 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": "Notion",
    "brandDomain": "notion.so",
    "competitors": [
        "Asana|asana.com",
        "ClickUp|clickup.com",
        "Trello|trello.com"
    ],
    "prompts": [
        "best note taking app for teams",
        "best project management tool for startups",
        "best all-in-one workspace app for remote work"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wheaten_steelpan/ai-visibility-checker").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": "Notion",
    "brandDomain": "notion.so",
    "competitors": [
        "Asana|asana.com",
        "ClickUp|clickup.com",
        "Trello|trello.com",
    ],
    "prompts": [
        "best note taking app for teams",
        "best project management tool for startups",
        "best all-in-one workspace app for remote work",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("wheaten_steelpan/ai-visibility-checker").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": "Notion",
  "brandDomain": "notion.so",
  "competitors": [
    "Asana|asana.com",
    "ClickUp|clickup.com",
    "Trello|trello.com"
  ],
  "prompts": [
    "best note taking app for teams",
    "best project management tool for startups",
    "best all-in-one workspace app for remote work"
  ]
}' |
apify call wheaten_steelpan/ai-visibility-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Visibility Checker — ChatGPT, Gemini & AI Overviews",
        "description": "Track how often ChatGPT, Gemini, Perplexity, Claude & Google AI Overviews mention and cite your brand versus competitors. GEO/AEO monitoring with visibility score, share of voice, cited sources and a forwardable HTML report.",
        "version": "0.1",
        "x-build-id": "fJQ9jAljDJkMXkfyG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wheaten_steelpan~ai-visibility-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wheaten_steelpan-ai-visibility-checker",
                "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/wheaten_steelpan~ai-visibility-checker/runs": {
            "post": {
                "operationId": "runs-sync-wheaten_steelpan-ai-visibility-checker",
                "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/wheaten_steelpan~ai-visibility-checker/run-sync": {
            "post": {
                "operationId": "run-sync-wheaten_steelpan-ai-visibility-checker",
                "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",
                    "prompts",
                    "platforms"
                ],
                "properties": {
                    "brandName": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "The brand to track in AI answers."
                    },
                    "brandAliases": {
                        "title": "Brand aliases",
                        "type": "array",
                        "description": "Alternative spellings or product names counted as brand mentions (e.g. 'HubSpot CRM' for 'HubSpot').",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandDomain": {
                        "title": "Brand domain",
                        "type": "string",
                        "description": "Your website domain, used to detect when AI answers cite your site (e.g. apify.com)."
                    },
                    "competitors": {
                        "title": "Competitors",
                        "type": "array",
                        "description": "One competitor per line as Name|domain, e.g. 'Zyte|zyte.com'. The name is matched in answer text, the domain in cited sources. A name alone ('Zyte') or a bare domain ('zyte.com') also works.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "prompts": {
                        "title": "Prompts to check",
                        "type": "array",
                        "description": "Buyer-intent questions your customers ask AI. 5-20 recommended.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platforms": {
                        "title": "Platforms",
                        "type": "array",
                        "description": "Which AI answer engines to check. Gemini and Google AI Overviews work out of the box. ChatGPT, Perplexity and Claude require your own API key below (your key, your quota — encrypted by Apify, used only inside your run to call that provider, never written to logs or results).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "gemini",
                                "googleAiOverviews",
                                "chatgpt",
                                "perplexity",
                                "claude"
                            ],
                            "enumTitles": [
                                "Gemini",
                                "Google AI Overviews",
                                "ChatGPT (requires your OpenAI API key)",
                                "Perplexity (requires your Perplexity API key)",
                                "Claude (requires your Anthropic API key)"
                            ]
                        },
                        "default": [
                            "gemini",
                            "googleAiOverviews"
                        ]
                    },
                    "countryCode": {
                        "title": "Country (optional)",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Two-letter country code (e.g. 'de', 'gb', 'br') to check visibility from that market. Google AI Overviews searches Google from that country; ChatGPT, Perplexity and Claude localize their web search to it. The Gemini API does not support location targeting yet, so Gemini checks are unaffected. Leave empty for the default (US/global) — existing setups behave exactly as before."
                    },
                    "language": {
                        "title": "Language (optional)",
                        "type": "string",
                        "description": "Language code (e.g. 'de', 'es', 'nl') for Google AI Overviews results. Tip: for the AI chat platforms (ChatGPT, Gemini, Perplexity, Claude) the answer language follows your prompts — write prompts in your target language. Leave empty for the default (English)."
                    },
                    "geminiApiKey": {
                        "title": "Gemini API key (optional)",
                        "type": "string",
                        "description": "Bring your own Google AI Studio key to run Gemini checks on your own quota."
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API key (required for the ChatGPT platform)",
                        "type": "string",
                        "description": "Create one at platform.openai.com/api-keys. Used only for your ChatGPT checks, on your own quota."
                    },
                    "perplexityApiKey": {
                        "title": "Perplexity API key (required for the Perplexity platform)",
                        "type": "string",
                        "description": "Create one in your Perplexity account settings. Used only for your Perplexity checks, on your own quota."
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API key (required for the Claude platform)",
                        "type": "string",
                        "description": "Create one at platform.claude.com. Used only for your Claude checks, on your own quota."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```