# AI Answer Visibility Monitor - GEO Brand Tracking API (`veska/ai-answer-visibility-monitor`) Actor

Is your brand named when AI assistants answer questions? No subscription, no prompt caps, pay per check. Live Google Search grounding, a mention RATE across runs, competitors named, sources cited, plus next steps. The affordable Profound and Otterly alternative. Agent-ready MCP.

- **URL**: https://apify.com/veska/ai-answer-visibility-monitor.md
- **Developed by:** [Veska Tools](https://apify.com/veska) (community)
- **Categories:** AI, Developer tools, MCP servers
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

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 Answer Visibility Monitor - GEO Brand Tracking API (no caps, pay per check)

Track whether your brand is mentioned when AI assistants answer questions in your category. Built for marketers, agencies, founders, and AI agents who need to know if they are visible in **AI search** (the answers people now get from ChatGPT, Gemini, Perplexity, and Google AI Overviews).

**The affordable, no-subscription, no-prompt-cap alternative to Profound, Otterly.AI, Peec, and Ranklytics.** Pay only for the checks you run. Bring your own keys. Run thousands of prompts for the price others charge for fifty.

This is **GEO** (Generative Engine Optimization), also called **AEO** (Answer Engine Optimization) or **AI SEO**: the new way to get found, now that buyers ask an AI instead of scrolling Google.

---

### Supported engines

| Engine | Key needed | Grounding | Cost |
|---|---|---|---|
| **Google Gemini** | Free Gemini key (aistudio.google.com, no credit card) | Live Google Search (configurable) | Free tier generous |
| **OpenAI (GPT-4o)** | OpenRouter key (openrouter.ai, paid) | Native web search via :online | ~$5 top-up = thousands of checks |
| **Perplexity (Sonar)** | OpenRouter key (same key as OpenAI) | Web-grounded by default | Same OpenRouter balance |

**One OpenRouter key powers both OpenAI and Perplexity.** Select multiple engines to compare how each AI talks about your brand, all in one run. One result row per (query, engine).

Gemini works standalone with a free key. To add OpenAI and Perplexity, top up ~$5 at openrouter.ai and paste the key. No lock-in, no subscription.

---

### Why this beats the expensive tools (we built it from your complaints)

| What people hate about other GEO tools | What we do |
|---|---|
| $300 to $500 a month subscriptions | No subscription. Pay per check, cents each. |
| Low prompt caps ("a flashlight, I need a floodlight") | **No caps.** Run as many prompts as you want. |
| ~$10 per prompt (Profound Lite) | About **$0.05 per AI check**. |
| Single yes/no looks erratic (answers change by the hour) | We run each prompt several times and report a **mention RATE (%)** plus a stability flag. We measure the volatility instead of hiding it. |
| "Great dashboard, but what now?" | Every result includes a plain-language **recommended_action** and the **exact web sources the AI cited**, so you know where to get mentioned. |
| Locked-in SaaS, hard to automate | **API and MCP-native.** Drops straight into your workflow or AI agent. |
| Only tracks one AI model | **Multi-engine.** Compare Gemini, OpenAI, and Perplexity side by side. |

We deliberately do not promise revenue attribution or full conversational-journey tracking, because no tool does that honestly yet. We would rather under-promise and be trusted.

---

### What you get (per query, per engine)

- **engine**: which AI answered (gemini, openai, perplexity, or demo)
- **mention_rate_pct**: % of runs where the AI named your brand (the headline number)
- **stability**: stable or volatile, so you know how much to trust it
- **times_mentioned / runs**: e.g. mentioned in 2 of 3 runs
- **avg_prominence**: 1 to 100, how early/prominently your brand appears
- **competitors_mentioned**: the rival brand names the AI named (auto-detected)
- **ai_sources**: the web pages the AI cited to build its answer (your citation targets)
- **recommended_action**: a plain next step
- **sample_answer**: a preview of the AI's actual answer

---

### Example output

```json
{
  "brand": "Notion",
  "query": "What is the best note-taking app in 2026?",
  "engine": "gemini",
  "model": "gemini-2.5-flash",
  "grounded": true,
  "runs": 3,
  "mention_rate_pct": 67,
  "times_mentioned": 2,
  "stability": "volatile",
  "avg_prominence": 54,
  "competitors_mentioned": ["Microsoft OneNote", "Obsidian", "Evernote"],
  "ai_sources": [
    {"title": "zapier.com", "url": "https://zapier.com/..."},
    {"title": "pcmag.com", "url": "https://pcmag.com/..."}
  ],
  "recommended_action": "Inconsistent: named in 2 of 3 runs, so the AI is unsure about you. Strengthen authoritative content and target zapier.com, pcmag.com for citations. Watch Microsoft OneNote, who shows up against you.",
  "sample_answer": "For note-taking in 2026, Notion remains a top all-in-one choice..."
}
````

***

### How to use it

1. Enter your **brand name** (e.g. "Notion", "Tesla", "Monday.com").
2. Enter the **questions** your customers would ask an AI: "What is the best X?", "Which Y should I use?", "How do I solve Z?".
3. Select which **engines** to check (Gemini, OpenAI, Perplexity, or all three).
4. Add your API key(s):
   - **Gemini**: free key (see below).
   - **OpenAI and/or Perplexity**: one OpenRouter key (see below).
5. Pick **runs per query** (default 3, for a reliable rate). You pay per AI check, so 3 runs of one query on 2 engines = 6 checks.
6. Run it. One rated result row per (question, engine). Schedule it daily or weekly on Apify to track movement over time.

No key yet? Leave them blank to see a labeled demo of the output format first.

***

### Get a free Gemini API key (2 minutes, no credit card)

1. Go to [aistudio.google.com](https://aistudio.google.com)
2. Sign in with a Google account
3. Click "Get API key" and copy it
4. Paste it into the `geminiApiKey` field

The free tier is generous. Because you bring your own key, your AI usage stays free or near-free.

### Get an OpenRouter key (for OpenAI and Perplexity)

1. Go to [openrouter.ai](https://openrouter.ai) and sign up
2. Top up your balance (~$5 is enough for thousands of checks)
3. Go to Keys, create an API key, and copy it
4. Paste it into the `openrouterApiKey` field

One key, one balance, two engines. No subscription. OpenRouter reaches GPT-4o with web search and Perplexity Sonar (and 200+ other models if you ever need them).

***

### Use as an MCP server (for AI agents)

This Actor works as an MCP (Model Context Protocol) server, so AI agents like Claude and ChatGPT can call it directly to check brand visibility with no human involvement. Ideal for automated GEO monitoring inside an agent workflow.

***

### Who this is for

- **Marketers and GEO/AEO agencies** reporting AI visibility to clients
- **Founders** checking if AI recommends them or a competitor
- **Developers and AI agents** that need GEO data via API, not a dashboard

Keywords: AI visibility checker, LLM brand tracker, AI search monitoring, track brand mentions in ChatGPT and Gemini, generative engine optimization tool, answer engine optimization, Profound alternative, Otterly alternative, GEO API, GEO MCP server, multi-engine AI visibility, compare AI engines.

***

### Important

This is a data and monitoring tool. It measures what AI assistants answer at query time; it does not change what they say. AI answers vary between runs (that is real, your customers see it too), which is exactly why we report a rate across multiple runs. Competitor names are auto-detected and labeled as such, not manually verified.

Profound, Otterly.AI, Peec, and Ranklytics are trademarks of their respective owners. Veska is independent and not affiliated with or endorsed by them. Any comparison is for informational purposes, based on publicly available pricing.

*Built by Veska. Real grounded GEO data. No caps, no subscription. Multi-engine.*

# Actor input Schema

## `brand` (type: `string`):

The brand, product, or company name to track. Example: Tesla

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

The questions your target customers would ask an AI assistant. One result row per question per engine. Example: 'What is the best electric car in 2026?'

## `engines` (type: `array`):

Which AI assistants to query. Select one or more. Gemini needs a free Gemini key. OpenAI and Perplexity both run through OpenRouter (one paid key powers both, get it at openrouter.ai). Engines without a key are skipped. Beta note: OpenAI and Perplexity are coded but not yet verified with a live key - marked beta until tested.

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

Your Google Gemini API key. Get one free at aistudio.google.com (no credit card). Leave blank to run a demo with sample output.

## `openrouterApiKey` (type: `string`):

Your OpenRouter API key. One key powers both OpenAI and Perplexity engines. Get it at openrouter.ai (paid, ~$5 top-up = thousands of checks). Only needed if you selected OpenAI or Perplexity above.

## `useGrounding` (type: `boolean`):

Gemini only. ON (recommended): the AI searches the live web before answering, so results match what real users see. This is real GEO data. Turn OFF only to save quota (then it answers from the model's memory, which is less accurate). OpenAI and Perplexity are always web-grounded.

## `runsPerQuery` (type: `integer`):

AI answers vary between runs. We check each query several times and report a mention RATE (%), not a misleading single yes/no. You pay per AI check, so 3 runs of one query on one engine = 3 checks. Set 1 for the cheapest quick check, higher for a more reliable rate.

## `geminiModel` (type: `string`):

Advanced: which Gemini model to use. Default gemini-2.5-flash is fast and supports grounding. Change only if Google updates model names. Does not affect OpenAI or Perplexity.

## Actor input object example

```json
{
  "brand": "Tesla",
  "queries": [
    "What is the best electric car to buy in 2026?",
    "Which EV brand has the best charging network?",
    "What car should I buy for long road trips?"
  ],
  "engines": [
    "gemini"
  ],
  "useGrounding": true,
  "runsPerQuery": 3,
  "geminiModel": "gemini-2.5-flash"
}
```

# 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 = {
    "brand": "Tesla",
    "queries": [
        "What is the best electric car to buy in 2026?",
        "Which EV brand has the best charging network?",
        "What car should I buy for long road trips?"
    ],
    "engines": [
        "gemini"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "brand": "Tesla",
    "queries": [
        "What is the best electric car to buy in 2026?",
        "Which EV brand has the best charging network?",
        "What car should I buy for long road trips?",
    ],
    "engines": ["gemini"],
}

# Run the Actor and wait for it to finish
run = client.actor("veska/ai-answer-visibility-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "brand": "Tesla",
  "queries": [
    "What is the best electric car to buy in 2026?",
    "Which EV brand has the best charging network?",
    "What car should I buy for long road trips?"
  ],
  "engines": [
    "gemini"
  ]
}' |
apify call veska/ai-answer-visibility-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Answer Visibility Monitor - GEO Brand Tracking API",
        "description": "Is your brand named when AI assistants answer questions? No subscription, no prompt caps, pay per check. Live Google Search grounding, a mention RATE across runs, competitors named, sources cited, plus next steps. The affordable Profound and Otterly alternative. Agent-ready MCP.",
        "version": "0.1",
        "x-build-id": "s3WDXvYt8HbH6VLM8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/veska~ai-answer-visibility-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-veska-ai-answer-visibility-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/veska~ai-answer-visibility-monitor/runs": {
            "post": {
                "operationId": "runs-sync-veska-ai-answer-visibility-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/veska~ai-answer-visibility-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-veska-ai-answer-visibility-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "brand",
                    "queries"
                ],
                "properties": {
                    "brand": {
                        "title": "Brand or product name",
                        "type": "string",
                        "description": "The brand, product, or company name to track. Example: Tesla"
                    },
                    "queries": {
                        "title": "Questions to check",
                        "type": "array",
                        "description": "The questions your target customers would ask an AI assistant. One result row per question per engine. Example: 'What is the best electric car in 2026?'",
                        "items": {
                            "type": "string"
                        }
                    },
                    "engines": {
                        "title": "AI engines to check",
                        "type": "array",
                        "description": "Which AI assistants to query. Select one or more. Gemini needs a free Gemini key. OpenAI and Perplexity both run through OpenRouter (one paid key powers both, get it at openrouter.ai). Engines without a key are skipped. Beta note: OpenAI and Perplexity are coded but not yet verified with a live key - marked beta until tested.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "gemini",
                                "openai",
                                "perplexity"
                            ],
                            "enumTitles": [
                                "Google Gemini (free key from aistudio.google.com)",
                                "OpenAI GPT-4o with web search (beta, needs OpenRouter key)",
                                "Perplexity Sonar web-grounded (beta, needs OpenRouter key)"
                            ]
                        },
                        "default": [
                            "gemini"
                        ]
                    },
                    "geminiApiKey": {
                        "title": "Gemini API key (free)",
                        "type": "string",
                        "description": "Your Google Gemini API key. Get one free at aistudio.google.com (no credit card). Leave blank to run a demo with sample output."
                    },
                    "openrouterApiKey": {
                        "title": "OpenRouter API key (for OpenAI and Perplexity)",
                        "type": "string",
                        "description": "Your OpenRouter API key. One key powers both OpenAI and Perplexity engines. Get it at openrouter.ai (paid, ~$5 top-up = thousands of checks). Only needed if you selected OpenAI or Perplexity above."
                    },
                    "useGrounding": {
                        "title": "Use live Google Search grounding (Gemini only, recommended)",
                        "type": "boolean",
                        "description": "Gemini only. ON (recommended): the AI searches the live web before answering, so results match what real users see. This is real GEO data. Turn OFF only to save quota (then it answers from the model's memory, which is less accurate). OpenAI and Perplexity are always web-grounded.",
                        "default": true
                    },
                    "runsPerQuery": {
                        "title": "Runs per query (for a reliable mention rate)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "AI answers vary between runs. We check each query several times and report a mention RATE (%), not a misleading single yes/no. You pay per AI check, so 3 runs of one query on one engine = 3 checks. Set 1 for the cheapest quick check, higher for a more reliable rate.",
                        "default": 3
                    },
                    "geminiModel": {
                        "title": "Gemini model (advanced)",
                        "type": "string",
                        "description": "Advanced: which Gemini model to use. Default gemini-2.5-flash is fast and supports grounding. Change only if Google updates model names. Does not affect OpenAI or Perplexity.",
                        "default": "gemini-2.5-flash"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
