# Google AI Overview & AI Mode Disruption Monitor (`doesaiknow/ai-overview-disruption-monitor`) Actor

Triage your SEO keyword portfolio against Google's AI answers: AI Overview presence, AI Mode citations, search volume, and a 0-100 disruption score per keyword.

- **URL**: https://apify.com/doesaiknow/ai-overview-disruption-monitor.md
- **Developed by:** [David S](https://apify.com/doesaiknow) (community)
- **Categories:** SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / keyword scored

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google AI Overview Disruption Monitor for SEO Keywords

Triage your SEO keyword portfolio against Google's AI answers. For every keyword you get one
decision row: whether an **AI Overview** is showing, whether **AI Mode** answers the query, who
the AI cites, the classic search volume, and a single **0–100 AI disruption score** that tells
you which keywords to defend, monitor, or deprioritize.

Built for SEO leads, publishers, and e-commerce content strategists who need to know where AI is
cannibalizing organic clicks — not another raw SERP dump. This measures click cannibalization per
keyword, not search volume trends.

### What does the AI Overview Disruption Monitor do?

Give it a list of keywords. For each one, the monitor checks Google's AI surfaces — the AI
Overview block above the organic results and the conversational AI Mode answer — joins in the
keyword's monthly search volume, and computes a disruption score plus a triage class. One keyword
in, one scored row out.

It answers one question at scale: *how much is Google's AI intercepting the clicks for this query,
and how urgently should I act?*

### Why track AI Overview disruption

- **One number per keyword.** A `disruption_score` from 0 to 100 collapses AI Overview presence,
  format richness, AI Mode presence, search volume, and citation concentration into a single
  comparable metric.
- **Ready-to-act triage.** Every row is classed `defend`, `monitor`, or `deprioritize` — filter
  the dataset and hand your team a work list, no spreadsheet math required.
- **Both AI surfaces, one row.** AI Overview *and* AI Mode are checked and merged, so you see the
  full AI footprint on a query, not just one block.
- **Citation intelligence.** See exactly which domains the AI cites and how concentrated those
  citations are (a winner-take-all query scores differently from a broad one).
- **Volume-weighted.** A disrupted head term and a disrupted long-tail are not the same emergency
  — the score reflects exposure.
- **Pay per keyword, no seat.** Flat $0.35 per delivered row; repeat keywords within 24 hours are
  served from cache and cost nothing.

### How to score AI Overview disruption for your keywords

1. Open the Actor and paste your keyword portfolio into the **Keywords** field (one phrase per
   line). Keywords are trimmed, lowercased, whitespace-collapsed, and de-duplicated, so two
   variants of the same phrase count as one row.
2. Run the Actor. It partitions cache hits first, enriches volume in a single batch call, then
   checks the AI surfaces for each new keyword.
3. Open the **Overview** dataset view for the at-a-glance list: keyword, triage class, disruption
   score, search volume, and AI Overview presence.
4. Switch to the **Defend** view to see only the highest-risk keywords (triage `defend`),
   ordered by disruption score — that is your priority defense list.
5. Export to JSON, CSV, or Excel, or pull the results from the API and feed them into your own
   SEO dashboard. Re-run every ~7 days to keep the picture current.

Minimal input:

```json
{
  "keywords": ["best crm", "ai seo tool", "how to invoice a client"]
}
````

### What data you get per keyword

One dataset row = one keyword. Every row always carries the same 16 keys (nothing missing, no raw
provider payload leaks through). Example row:

```json
{
  "keyword": "best crm",
  "status": "ok",
  "ai_overview_present": true,
  "ai_overview_format": "text_with_citations",
  "aio_cited_domains": ["hubspot.com", "salesforce.com", "zoho.com"],
  "ai_mode_answer_present": true,
  "ai_mode_answer_length": 1180,
  "ai_mode_cited_domains": ["hubspot.com", "forbes.com"],
  "ai_mode_has_links": true,
  "search_volume": 135000,
  "citation_concentration": 0.28,
  "disruption_score": 84,
  "triage_class": "defend",
  "source": "primary",
  "checked_at": "2026-07-23T09:14:02.371Z",
  "cache_hit": false
}
```

| Field | Type | What it tells you |
|---|---|---|
| `keyword` | string | The normalized query (echo of input) |
| `status` | `"ok"` | `"not_found"` | `not_found` = no AI SERP data for the phrase — still a delivered answer |
| `ai_overview_present` | boolean | Is a Google AI Overview shown for this keyword? |
| `ai_overview_format` | string | null | Block richness: `text`, `text_with_citations`, or `text_with_videos`; `null` when absent |
| `aio_cited_domains` | string\[] | Domains the AI Overview cites (processed, deduplicated) |
| `ai_mode_answer_present` | boolean | null | Does AI Mode answer the query? (`null` on the fallback path) |
| `ai_mode_answer_length` | integer | null | Length of the AI Mode answer in characters |
| `ai_mode_cited_domains` | string\[] | null | Domains AI Mode cites |
| `ai_mode_has_links` | boolean | null | Does the AI Mode answer contain outbound links? |
| `search_volume` | integer | null | Classic monthly search volume; `null` when unavailable |
| `citation_concentration` | float 0–1 | How concentrated the AI citations are across domains (HHI) |
| `disruption_score` | integer 0–100 | The headline metric — see below |
| `triage_class` | `"defend"` | `"monitor"` | `"deprioritize"` | Decision bucket from the score |
| `source` | `"primary"` | `"fallback"` | Which data path filled the row |
| `checked_at` | ISO 8601 | When this observation was taken |
| `cache_hit` | boolean | `true` when the row was served free from the 24h cache |
| `tracked_domain_cited` | boolean | null | `true` when any of your `trackedDomains` (or a subdomain) is cited in the AI Overview or AI Mode answer; `null` when you did not pass `trackedDomains` |

### AI disruption score and triage explained

The `disruption_score` (0–100) sums five weighted components:

- **AI Overview presence** — the single biggest click cannibalizer when an AI block sits above the
  organic results.
- **AI Overview format** — a richer block (citations, videos) holds the user longer than plain
  text.
- **AI Mode presence** — a second AI surface intercepting the same query.
- **Search volume** — log-scaled exposure, so head terms outweigh long-tail at equal disruption.
- **Citation concentration** — a winner-take-all query where the AI cites a handful of domains is
  scored higher than one that cites broadly.

Triage thresholds are fixed and inclusive: score **≥ 70 → `defend`**, **40–69 → `monitor`**,
**≤ 39 → `deprioritize`**. An unknown search volume never inflates a score.

### Input parameters

| Field | Required | Notes |
|---|---|---|
| `keywords` | yes | Your SEO keyword portfolio (min 1). Each phrase yields one scored row. Normalized and de-duplicated before scoring. Results use google.com in English. |
| `trackedDomains` | no | Up to 50 of your domains (bare hosts — protocol and `www.` are stripped). Each row then reports `tracked_domain_cited`: whether the AI answer cites your domain or any of its subdomains. |

This actor is intentionally stateless in v1 — no geo, language, or location inputs. All keywords
are checked against google.com in English. You can also run it programmatically via the Apify API
and through the Apify MCP server (`mcp.apify.com`), so AI assistants can trigger it from your
keyword list.

### How much does the Google AI Overview Disruption Monitor cost?

Billing uses Apify's pay-per-event model. You pay per **delivered row**, not per input keyword and
not per upstream call.

| Event | When | Price |
|---|---|---|
| Run start | Once per run | $0.05 (flat, one-time) |
| Keyword scored | Per delivered row | $0.35 per keyword |

The $0.35 per-keyword price is flat across every Apify plan tier. **You are never charged for:**

- **Cache hits** — a keyword scored in the last 24 hours is served from cache and bills nothing
  beyond the one-time run start.
- **Failures** — a keyword whose data could not be fetched is skipped and never billed.

A `not_found` result **is** a delivered answer and is billed as one keyword — knowing a query has
no AI SERP data is a result. On FREE accounts the run stops before the first paid call once your
plan limit is reached, so you are never charged beyond your balance.

### Google AI Overview Disruption Monitor vs manual SERP checks

| | This actor | Manual SERP checks | Rank trackers |
|---|---|---|---|
| Covers AI Overview | Yes | Yes, one query at a time | Rarely |
| Covers AI Mode | Yes | Manual, tedious | No |
| Volume-weighted score | Yes, 0–100 | No | No |
| Ready-to-act triage | `defend` / `monitor` / `deprioritize` | No | No |
| Citation concentration | Yes (HHI) | No | No |
| Cost model | $0.35 per keyword, cache free | Your time | Monthly seat |
| Scales to a full portfolio | Yes, batched | No | Yes, but no AI signal |

### How the monitor stays reliable

- **Cache (24h):** identical keywords within 24 hours are served from cache — free, with the
  original observation time preserved.
- **Deterministic scoring:** the same inputs always produce the same score and class. The scoring
  version is part of the cache key, so a formula change cleanly invalidates old entries.
- **Fallback path:** if the primary source fails, the row is retried through a secondary source
  (`source: "fallback"`). On that path the AI Mode fields degrade to `null` (meaning "not
  checked", distinct from `false`), and the score is computed from the AI Overview alone.
- **Plan-limit guard:** on FREE accounts the run stops before the first paid request when the
  forecast exceeds your plan limit — nothing is charged beyond your balance.

### What this actor does not do

- It does **not** rewrite or generate content, keywords, or meta tags.
- It does **not** crawl or audit your website.
- It does **not** report classic organic rankings or positions.
- It does **not** support per-keyword geo or language targeting in v1 — everything is checked
  against google.com in English.
- It does **not** return raw search-engine payloads — only the processed, decision-ready fields
  above.
- It does **not** measure search-volume trends over time (that is a different job) — it measures
  AI click cannibalization right now.

### FAQ

#### What is an AI Overview disruption score?

A single 0–100 number per keyword that combines AI Overview presence and format, AI Mode presence,
search volume, and how concentrated the AI's citations are. Higher means AI is intercepting more of
the clicks for that query.

#### How is the triage class decided?

Directly from the score: `defend` at 70 or above, `monitor` from 40 to 69, and `deprioritize` at
39 or below. The thresholds are fixed so the classes are comparable across runs.

#### What is the difference between AI Overview and AI Mode?

The AI Overview is the AI-generated block that appears above Google's organic results. AI Mode is
Google's conversational answer experience. This actor checks both and merges them into one row.

#### Do cache hits cost anything?

No. A keyword scored within the last 24 hours is served from cache with `cache_hit: true` and is
never billed beyond the one-time run start.

#### How often should I run it?

About every 7 days keeps your triage current without over-spending, since AI Overview presence for
a query is relatively stable week to week. You can also run it via the Apify API or the MCP server.

### Related actors

Pair this with the rest of the doesaiknow suite for a fuller AI-search and SEO view — local pack
and AI Overview tracking, and listing optimization. See the publisher page for companion actors.

### Legal & support

- This actor reports **publicly visible** Google AI Overview and AI Mode results for the keywords
  you provide. Data is sourced from stable vendor **APIs**, not from scraping, proxy rotation, or
  anti-bot circumvention. It stores no personal data.
- Output is provided **as-is** for competitive-intelligence and SEO-monitoring purposes. Search
  results and AI answers change constantly; figures are point-in-time observations, not guarantees.
- Google is a trademark of Google LLC. This actor is **not affiliated with, endorsed by, or
  sponsored by** Google.
- You are responsible for using the output in line with the terms of the platforms you operate on
  and applicable law in your jurisdiction.
- Questions or a bug? Open an issue on the Actor's **Issues** tab, or see the **API** tab for
  integration details.

### SEO keywords

Google AI Overview, AI Overview monitor, AI Overview SEO, AI Overview tracker, AI Mode SEO,
AI search optimization, AI SEO tool, click cannibalization, keyword triage, SGE tracker,
generative search optimization, AI disruption score, SERP AI monitoring, keyword portfolio audit,
AI Overview citations, search volume triage, AI Overview presence, defend keywords, SEO monitoring,
AI answer tracking, Google AI answers, content strategy SEO, organic click loss, AI cited domains.

Built by doesaiknow.

# Actor input Schema

## `keywords` (type: `array`):

Your SEO keyword portfolio. Each keyword is triaged for AI Overview and AI Mode disruption and yields one result row. Keywords are normalized (trimmed, lowercased, whitespace collapsed) and de-duplicated before scoring, so two variants of the same phrase count as one row. Results use google.com in English.

## `trackedDomains` (type: `array`):

Your domains to check for citations. Each result row gets tracked\_domain\_cited: true when any of these domains (or their subdomains) is cited in the AI Overview or AI Mode answer, false when checked but not cited, null when this list is empty. Enter bare domains — protocol and www are stripped automatically.

## Actor input object example

```json
{
  "keywords": [
    "best crm",
    "ai seo tool"
  ],
  "trackedDomains": [
    "example.com"
  ]
}
```

# Actor output Schema

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

All delivered rows: keyword, status, AI Overview / AI Mode signals, search volume, citation concentration, disruption\_score, triage\_class, tracked\_domain\_cited, source.

## `cache` (type: `string`):

Per-keyword scored rows cached for 24h; a cache hit re-delivers the row free (never billed).

# 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 = {
    "keywords": [
        "best crm",
        "ai seo tool"
    ],
    "trackedDomains": [
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("doesaiknow/ai-overview-disruption-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "best crm",
        "ai seo tool",
    ],
    "trackedDomains": ["example.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("doesaiknow/ai-overview-disruption-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 '{
  "keywords": [
    "best crm",
    "ai seo tool"
  ],
  "trackedDomains": [
    "example.com"
  ]
}' |
apify call doesaiknow/ai-overview-disruption-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google AI Overview & AI Mode Disruption Monitor",
        "description": "Triage your SEO keyword portfolio against Google's AI answers: AI Overview presence, AI Mode citations, search volume, and a 0-100 disruption score per keyword.",
        "version": "0.1",
        "x-build-id": "UG8FXJD4GXUVoABmF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/doesaiknow~ai-overview-disruption-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-doesaiknow-ai-overview-disruption-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/doesaiknow~ai-overview-disruption-monitor/runs": {
            "post": {
                "operationId": "runs-sync-doesaiknow-ai-overview-disruption-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/doesaiknow~ai-overview-disruption-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-doesaiknow-ai-overview-disruption-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Your SEO keyword portfolio. Each keyword is triaged for AI Overview and AI Mode disruption and yields one result row. Keywords are normalized (trimmed, lowercased, whitespace collapsed) and de-duplicated before scoring, so two variants of the same phrase count as one row. Results use google.com in English.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "trackedDomains": {
                        "title": "Tracked domains (optional)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Your domains to check for citations. Each result row gets tracked_domain_cited: true when any of these domains (or their subdomains) is cited in the AI Overview or AI Mode answer, false when checked but not cited, null when this list is empty. Enter bare domains — protocol and www are stripped automatically.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
