# AI Visibility / GEO Monitor (`westerly_breaker/ai-visibility-geo-monitor`) Actor Measure whether Claude mentions your brand in a live web-search-grounded answer, with sentiment and cited sources. - **URL**: https://apify.com/westerly\_breaker/ai-visibility-geo-monitor.md - **Developed by:** [Daniel Posztos](https://apify.com/westerly_breaker) (community) - **Categories:** AI, Marketing, SEO tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.01 / 1,000 dataset items 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 / GEO Monitor — Track Your Brand in Claude's Answers **SEO title:** AI Visibility / GEO Monitor — Brand in AI Answers **SEO description:** Measure whether Claude mentions your brand in a live, web-search-grounded answer — with sentiment, first-mention position, and the sources it cited. Track AI visibility vs competitors. When people ask an AI assistant "what's the best project management software?", the brands it names — and the order it names them in — are the new search ranking. **GEO (Generative Engine Optimization) / AI-visibility monitoring** is tracking how your brand shows up in those AI answers versus your competitors. This actor does exactly that: for each query you give it, it asks a Claude model with **live web search** enabled, then checks every brand you list against that **same** grounded answer, returning whether each brand was mentioned, its **sentiment**, its **first-mention position** relative to the other brands, and the **sources** the answer drew on. Built for brand/SEO teams tracking share-of-voice in AI answers, competitive-intelligence tooling, and AI agents that need a structured "did we show up, and how" signal instead of eyeballing chat transcripts. ### Why this exists Classic SEO tracks where you rank on a results page. But a growing share of "best X" and "top Y" research now happens inside AI assistants that return one synthesized answer naming a handful of brands — no page of blue links. If a competitor is named first and you're not named at all, you've lost that impression, and no rank tracker will tell you. This actor gives you a repeatable, structured measurement of that surface: ask the real questions your buyers ask, see which brands the AI actually surfaces, and watch it over time. Because AI answers vary run to run (especially with live web search), you can re-ask each query up to 5 times (`runs_per_query`) to sample the variance rather than trusting a single draw. ### What it does / methodology For each `(query, run)`: 1. **One shared answer.** It asks a single Claude model (default `claude-sonnet-5`) your query with the live `web_search` tool enabled — one grounded answer per query×run. This is the expensive step, and it happens **once**, no matter how many brands you're tracking. 2. **Cheap per-brand check.** It then runs one small, structured-output classification call (on cheap `claude-haiku-4-5`) per brand against that **same** answer text — is this brand mentioned, with what sentiment, and where does its first mention fall. Adding brands does **not** re-run the expensive answer generation. 3. **Deterministic ranking.** `position` is computed deterministically by locating each brand's first-mention anchor in the answer text and ranking those offsets (1 = earliest-mentioned), not asserted by the model. One row is emitted per `(engine, query, brand, run)`. > **Methodology note:** `brand_mentioned` and `sentiment` are the model's own classification of its own answer, not independently verified ground truth. Treat them as a strong, consistent signal — the same way you'd treat any AI-inferred label — not as a legal determination. ### API key model — this is NOT bring-your-own-key Unlike some actors in this portfolio, **you do not supply an Anthropic API key.** This actor calls Claude on our shared key, and the per-event price you pay covers that upstream cost (LLM generation tokens + the web-search tool fee + the per-brand classification). That's the whole reason the pricing is structured the way it is below — you're paying for the AI answer, not just a data transformation. There is no key field in the input, and nothing about your Anthropic account is involved. ### Input | Field | Type | Default | Description | |---|---|---|---| | `brands` | array of strings | — | **Required, non-empty, max 20.** Brand names to look for in each answer, e.g. `["Notion", "Asana"]`. Every brand is checked against the SAME shared answer per query×run (one cheap classification each), so adding brands does not multiply the expensive generation cost. Blank entries are dropped. | | `queries` | array of strings | — | **Required, non-empty, max 20.** Search-style questions to ask, e.g. `["best project management software"]`. Each query×run costs one live web-search-grounded generation call. Blank entries are dropped. | | `engines` | array of strings | `["anthropic"]` | Launch supports **only** `"anthropic"` (a single Claude model with live web search) — it does NOT query ChatGPT, Gemini, or Perplexity. The field is accepted for forward-compatibility with future engines; any other value fails fast with a speaking error. Omit it to take the default. | | `runs_per_query` | integer (1–5) | `1` | How many times to independently re-ask each query, to sample answer-to-answer variance. | | `model` | string | `"claude-sonnet-5"` | `"claude-sonnet-5"` (default, the cost/quality balance this actor is priced around), `"claude-opus-4-8"` (higher quality, pricier), or `"claude-haiku-4-5"` (cheapest, but does **not** support the live web-search tool — usable only with `"search": false`). | | `search` | boolean | `true` | Whether to enable live web search for grounding. With `false`, answers reflect the model's training data only (no live results, `cited_sources` empty). `claude-haiku-4-5` requires `search: false`. | Additional guardrail: `queries × runs_per_query` (the count of expensive upstream generation calls) is capped at **60 per run** — independent of how many brands you track — to protect the shared Anthropic credit. Exceed it and the run fails fast telling you to trim `queries`/`runs_per_query` or split into multiple runs. #### Worked example — input ```json { "brands": ["Asana", "Monday.com", "ClickUp"], "queries": ["best project management software"], "model": "claude-sonnet-5", "search": true, "runs_per_query": 1 } ```` #### Worked example — output (1 row of 3, representative live shape) ```json { "engine": "anthropic", "query": "best project management software", "brand": "Asana", "run_index": 0, "brand_mentioned": true, "position": 1, "sentiment": "neutral", "cited_sources": [ "https://www.pcmag.com/picks/the-best-project-management-software", "https://zapier.com/blog/best-project-management-software/" ], "raw_answer_snippet": "There's no single \"best\" project management software — the right choice depends on your team size and workflow. Top picks by use case: Asana — a work management platform best for marketing/operations teams... Monday.com... ClickUp..." } ``` This run produced 3 rows (one per brand) sharing that same `raw_answer_snippet` and `cited_sources`; `position` ranks the brands by where each is first mentioned in the answer (here Asana = 1). A brand the answer never named would come back with `brand_mentioned: false`, `position: null`, `sentiment: null`. ### Output schema One row per `(engine, query, brand, run)`. See `.actor/dataset_schema.json` for the full JSON Schema. | Field | Type | Notes | |---|---|---| | `engine` | string | Always `"anthropic"` at launch | | `query` | string | The query that was asked | | `brand` | string | The brand this row measures | | `run_index` | integer | 0-indexed repetition number for this query (see `runs_per_query`) — lets you measure answer-to-answer variance | | `brand_mentioned` | boolean | Whether the brand appeared in the answer, per the model's classification (model-inferred, not ground truth) | | `position` | integer or null | 1-indexed rank of this brand's first mention among all mentioned brands in the SAME answer (1 = earliest). `null` if not mentioned, or mentioned but the exact text couldn't be located for ranking | | `sentiment` | string or null | `"positive"`, `"neutral"`, `"negative"`, or `null` (when not mentioned) — how the answer portrays the brand | | `cited_sources` | array of strings | URLs the answer's web search drew on (surfaced and/or explicitly cited). Empty if `search` was false or nothing citable came back | | `raw_answer_snippet` | string | The model's full answer text (all brands in the same query×run share this SAME text), truncated to 2000 characters with a trailing `...` if longer | ### Pricing (pay-per-event) | Event | Price | When it's charged | |---|---|---| | `answer-generation` | $0.40 | **Once per `(query, run)`** — the shared, live web-search-grounded Claude answer that every brand in the run is checked against | | `brand-check` | $0.01 | Once per result row — one `(engine, query, brand, run)` row with its mention/sentiment/position/sources | Plus Apify's own `apify-actor-start` synthetic event (first 5 seconds of compute free, platform-managed). **Why the price is split this way:** the expensive part of a query is the one live-grounded answer (LLM tokens + web-search fee), and that answer is **shared** across every brand you check — the actor never re-asks the question per competitor. So you pay for the answer **once** (`answer-generation`), then a small flat fee per brand row you get back (`brand-check`). Tracking 10 competitors against a query costs one generation plus ten cheap row checks, not ten full answers. You are **not** double-charged per competitor. **Worked cost example:** 10 queries × 5 brands × 1 run = `10 × $0.40` (one shared answer per query) `+ 50 × $0.01` (one row per brand per query) = **$4.00 + $0.50 = $4.50** — about **$0.09 per brand-row**. A single-brand, single-query run is `$0.40 + $0.01 = $0.41`. If a run's cost would exceed the `Max total charge USD` you set, the actor stops gracefully at exactly that point: it never generates an answer it can't afford to deliver at least one paid brand row for (it checks the budget for the `answer-generation` event **plus** one `brand-check` row before spending anything on the AI call), and every brand row it delivers was paid for — nothing paid-for is ever dropped, no crash. ### Error messages - **Missing/empty `brands`:** *"Missing 'brands': provide a non-empty list of brand names to check for..."* — exit 1, no AI call made. - **Missing/empty `queries`:** *"Missing 'queries': provide a non-empty list of search-style questions..."* — exit 1, no AI call made. - **Unsupported `engines` value:** states that only `"anthropic"` is supported at launch and that the field exists for forward-compatibility — exit 1. - **Unsupported `model`:** lists the exact allowed values — exit 1. - **`claude-haiku-4-5` with `search: true`:** *"...does not support the web\_search\_20260209 tool this actor uses... Either switch 'model'... or set 'search': false..."* — exit 1. - **Too many upstream calls (`queries × runs_per_query > 60`):** explains the cap protects the shared Anthropic credit and to trim/split — exit 1, no AI call made. - **0 rows with otherwise valid input:** not an error — the run succeeds, but the log has an explicit `WARNING: 0 results produced despite valid input (...)` line and the status message says so. ### How it works 1. Validate structural input (brands/queries non-empty, model/engine/search coherent, upstream-call cap) — fails fast with NO AI call at all if anything is wrong, so a bad input never touches the shared Anthropic credit. 2. For each `(query, run)`: check the budget can cover one `answer-generation` + one `brand-check` row **before** spending anything, then ask Claude the query once with live web search. 3. Charge the shared `answer-generation` event once, then classify that same answer against every brand (cheap Haiku call each) and rank first mentions. 4. Charge-and-deliver each brand row atomically — whatever is charged is delivered, and vice versa. 5. 0 rows with valid input logs an explicit warning instead of looking like a normal empty run. ### Known limitations (documented, not hidden) - **Single engine at launch.** Only Anthropic (one Claude model with live web search). No ChatGPT, Gemini, or Perplexity yet — the `engines` field is a forward-compatibility placeholder, not multiple live engines today. - **Live answers vary run to run.** Web-grounded AI answers are non-deterministic; the same query can name different brands on different runs. Use `runs_per_query` (up to 5) to sample the distribution rather than reading one draw as gospel. - **Mention/sentiment are model-inferred.** `brand_mentioned` and `sentiment` are the model's classification of its own answer, not independently verified ground truth (see the methodology note above). - **Not affiliated with any monitored brand.** This actor measures how AI answers portray brands you name; it has no relationship with, and makes no claim on behalf of, any of them. Brand names are your inputs. - **`web_search` requires Sonnet 5 or Opus.** `claude-haiku-4-5` can only run ungrounded (`search: false`), which reflects training data, not live web results. ### Data source Answers are generated by [Anthropic's Claude](https://www.anthropic.com/) models with Anthropic's server-side `web_search` tool for live grounding. This actor uses a shared Anthropic key (not bring-your-own-key — see "API key model" above); the per-event price covers that upstream cost. # Actor input Schema ## `brands` (type: `array`): Brand names to look for in each generated answer, e.g. \["Acme", "Globex"]. Required, non-empty, max 20. Every brand is checked against the SAME generated answer for a given query/run (cheap: one classification call per brand), so adding brands does not multiply the expensive web-search+generation cost. ## `queries` (type: `array`): Search-style questions to ask the AI model, e.g. "best project management software for small teams". Required, non-empty, max 20. Each query costs one live web-search-grounded generation call, shared across every brand in 'brands'. ## `engines` (type: `array`): Which AI engine(s) to query. LAUNCH SUPPORTS ONLY "anthropic" (one Claude model with web search) -- this does NOT query ChatGPT, Gemini, or Perplexity, despite accepting a list for forward-compatibility with future engines. Any other value fails the run with a clear error. ## `model` (type: `string`): Which Claude model generates the answer. "claude-sonnet-5" (default) is the cost/quality balance this actor is priced around. "claude-opus-4-8" is higher quality and more expensive. "claude-haiku-4-5" is cheapest but does NOT support the dynamic-filtering web search tool this actor uses -- only usable with 'search': false (no live grounding). ## `runs_per_query` (type: `integer`): How many times to independently re-ask each query (for variance measurement -- AI answers vary run to run, especially with live web search). Each run bills one shared 'answer-generation' event plus one 'brand-check' row event per brand. Must be between 1 and 5. ## `search` (type: `boolean`): Whether the model may search the web for its answer (recommended: true -- this is the whole point of a GEO/AI-visibility check, since it measures what the model says RIGHT NOW, not just from its training data). Set false only to test cheaper/ungrounded answers or when using 'claude-haiku-4-5' (which doesn't support this actor's web search tool version). ## Actor input object example ```json { "brands": [ "Notion", "Asana" ], "queries": [ "best project management software for small teams" ], "engines": [ "anthropic" ], "model": "claude-sonnet-5", "runs_per_query": 1, "search": true } ``` # Actor output Schema ## `rows` (type: `string`): One row per (engine, query, brand, run) combination, stored in the run's default dataset. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "brands": [ "Notion", "Asana" ], "queries": [ "best project management software for small teams" ] }; // Run the Actor and wait for it to finish const run = await client.actor("westerly_breaker/ai-visibility-geo-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "brands": [ "Notion", "Asana", ], "queries": ["best project management software for small teams"], } # Run the Actor and wait for it to finish run = client.actor("westerly_breaker/ai-visibility-geo-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 '{ "brands": [ "Notion", "Asana" ], "queries": [ "best project management software for small teams" ] }' | apify call westerly_breaker/ai-visibility-geo-monitor --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=westerly_breaker/ai-visibility-geo-monitor", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "AI Visibility / GEO Monitor", "description": "Measure whether Claude mentions your brand in a live web-search-grounded answer, with sentiment and cited sources.", "version": "0.1", "x-build-id": "ueQNCL18fvbIwpyD1" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/westerly_breaker~ai-visibility-geo-monitor/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-westerly_breaker-ai-visibility-geo-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/westerly_breaker~ai-visibility-geo-monitor/runs": { "post": { "operationId": "runs-sync-westerly_breaker-ai-visibility-geo-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/westerly_breaker~ai-visibility-geo-monitor/run-sync": { "post": { "operationId": "run-sync-westerly_breaker-ai-visibility-geo-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": [ "brands", "queries" ], "properties": { "brands": { "title": "Brands to check", "type": "array", "description": "Brand names to look for in each generated answer, e.g. [\"Acme\", \"Globex\"]. Required, non-empty, max 20. Every brand is checked against the SAME generated answer for a given query/run (cheap: one classification call per brand), so adding brands does not multiply the expensive web-search+generation cost.", "items": { "type": "string" } }, "queries": { "title": "Queries to ask", "type": "array", "description": "Search-style questions to ask the AI model, e.g. \"best project management software for small teams\". Required, non-empty, max 20. Each query costs one live web-search-grounded generation call, shared across every brand in 'brands'.", "items": { "type": "string" } }, "engines": { "title": "Engines", "type": "array", "description": "Which AI engine(s) to query. LAUNCH SUPPORTS ONLY \"anthropic\" (one Claude model with web search) -- this does NOT query ChatGPT, Gemini, or Perplexity, despite accepting a list for forward-compatibility with future engines. Any other value fails the run with a clear error.", "items": { "type": "string", "enum": [ "anthropic" ], "enumTitles": [ "Anthropic (Claude)" ] }, "default": [ "anthropic" ] }, "model": { "title": "Claude model", "enum": [ "claude-sonnet-5", "claude-opus-4-8", "claude-haiku-4-5" ], "type": "string", "description": "Which Claude model generates the answer. \"claude-sonnet-5\" (default) is the cost/quality balance this actor is priced around. \"claude-opus-4-8\" is higher quality and more expensive. \"claude-haiku-4-5\" is cheapest but does NOT support the dynamic-filtering web search tool this actor uses -- only usable with 'search': false (no live grounding).", "default": "claude-sonnet-5" }, "runs_per_query": { "title": "Runs per query", "minimum": 1, "maximum": 5, "type": "integer", "description": "How many times to independently re-ask each query (for variance measurement -- AI answers vary run to run, especially with live web search). Each run bills one shared 'answer-generation' event plus one 'brand-check' row event per brand. Must be between 1 and 5.", "default": 1 }, "search": { "title": "Enable live web search", "type": "boolean", "description": "Whether the model may search the web for its answer (recommended: true -- this is the whole point of a GEO/AI-visibility check, since it measures what the model says RIGHT NOW, not just from its training data). Set false only to test cheaper/ungrounded answers or when using 'claude-haiku-4-5' (which doesn't support this actor's web search tool version).", "default": true } } }, "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 } } } } } } } } } } ```