# AI GEO Recommendation Tracker (`muhammadafzal/ai-geo-rec-tracker`) Actor

Track brand visibility across ChatGPT, Claude, Gemini and Perplexity with actionable GEO recommendations and agency-ready HTML reports.

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

## Pricing

from $25.00 / 1,000 prompt x engine checks

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

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

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

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


# README

## AI Visibility Recommendation Tracker - ChatGPT, Claude, Gemini, Perplexity

Track your brand's visibility across four AI answer engines and get **actionable GEO recommendations** to improve it. Detects mentions, positions, share-of-voice, citations, and sentiment — then generates a prioritized, rule-based improvement plan and agency-ready HTML report.

### What It Does

Queries ChatGPT (GPT-4o-mini), Claude (Sonnet 4), Gemini (2.5 Flash), and Perplexity (Sonar) through a **single OpenRouter API key** with your tracked prompts. For each prompt × engine combination, it:

1. **Detects brand mentions** — is your brand named? How many times? In what context?
2. **Ranks your position** — among you and your listed competitors, where do you appear first?
3. **Computes share-of-voice** — what percentage of the tracked-brand mentions are yours?
4. **Extracts citations** — what sources does the AI cite? Is your domain among them?
5. **Scores sentiment** — positive, neutral, or negative classification of how you're described.
6. **Compares vs previous runs** — gained, lost, improved, or declined across tracked keywords and engines.
7. **Generates GEO recommendations** — a prioritized action plan with concrete steps: what content to create, which authority signals to build, and where the gaps are.
8. **Produces a shareable HTML report** — visibility score cards, per-platform breakdowns, citation analysis, and all recommendations in a self-contained file.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `brandName` | string | **Yes** | Brand/company/product to track (e.g., "Notion") |
| `brandDomain` | string | No | Your website domain for citation detection (e.g., "notion.so") |
| `industry` | string | No | Category for auto-generating prompts (e.g., "productivity software") |
| `prompts` | string[] | No | Exact questions to monitor; auto-generated from industry if empty |
| `competitorBrands` | string[] | No | Competitor brand names for position and share-of-voice comparison |
| `competitorDomains` | string[] | No | Competitor domains for citation gap detection |
| `generateHtmlReport` | boolean | No | Produce an HTML report in key-value store (default: true) |
| `trackingId` | string | No | Stable ID for cross-run history comparison |
| `maxPrompts` | integer | No | Cap on prompts per run (1-200, default: 25) |
| `useWebSearch` | boolean | No | Enable live web search via OpenRouter plugin (default: true) |
| `webSearchResults` | integer | No | Number of web results per query (1-10, default: 3) |
| `models` | object | No | Per-platform OpenRouter model slug overrides |

### Output

#### Dataset (one row per prompt × engine)
Each record contains: `brand`, `brand_domain`, `engine`, `model_used`, `prompt`, `mentioned`, `position`, `share_of_voice`, `cited`, `citations`, `brand_cited_url`, `mention_count`, `mention_context`, `sentiment`, `competitors_mentioned`, `topic_keywords`, `citation_domains`, `competitor_domains_cited`, `previous_mentioned`, `previous_position`, `position_change`, `visibility_status`, `error`, `checked_at`

#### Key-Value Store

| Key | Type | Description |
|-----|------|-------------|
| `SUMMARY` | JSON | Visibility score, per-engine breakdown, trend deltas, top cited domains |
| `RECOMMENDATIONS` | JSON | Prioritized action plan with 5 categories, severity levels, findings, and impact estimates |
| `REPORT` | HTML | Agency-ready self-contained report (when `generateHtmlReport` is true) |

#### Recommendation Categories

| Category | What It Detects | Example Action |
|----------|----------------|----------------|
| **Visibility** | Brand absent from checks | Create content targeting missing topics |
| **Citation** | Domain not cited, competitors are | Build authority with AI-trusted domains |
| **Sentiment** | Negative or neutral mentions | Improve brand perception and reviews |
| **Position** | Low rank among competitors | Strengthen E-E-A-T and authority signals |
| **Coverage** | Visible for some prompts but not others | Fill content gaps in uncovered topics |

### Pricing

This actor uses **Pay-Per-Event** pricing:

| Event | Price | Description |
|-------|-------|-------------|
| `actor-start` | $0.00005 | One-time initialization fee |
| `prompt-engine-check` | $0.025 | Per prompt × engine check (all analysis, citations, and recommendations included) |

**Example:** 4 prompts × 4 engines = 16 checks × $0.025 = $0.40 per run.

### Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `OPENROUTER_API_KEY` | **Yes** | Your OpenRouter API key for unified multi-LLM access |

### Schedule It

Set up a daily or weekly schedule in Apify Console to build a visibility history. The actor compares each run against the previous one, producing trend data (gained/lost/improved/declined) that surfaces negative movement before it compounds.

### Use Cases

- **Agencies** — Produce client-ready GEO reports with concrete recommendations and visual scorecards
- **SEO/GEO teams** — Identify content gaps, authority weaknesses, and citation opportunities across AI engines
- **Brand marketers** — Monitor how AI answer engines describe your brand vs competitors
- **MCP/AI agents** — Clean structured output with semantic field names for programmatic consumption

### Documentation & Integration

Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools. Use the Apify API to fetch results programmatically from your dashboard, data pipeline, or LLM agent.

Get the [OpenRouter API key](https://openrouter.ai/keys) to start tracking.

# Actor input Schema

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

The brand, company, or product to track in AI answers (e.g., 'Notion', 'Tesla'). Used as the primary entity for mention detection, position ranking, share-of-voice computation, and recommendation generation.
## `brandDomain` (type: `string`):

Your brand's website domain (e.g., 'notion.so'). Used to detect when AI engines cite your site as a source and to compare citation rates against competitor domains. Leave empty to skip domain-based citation matching.
## `industry` (type: `string`):

Your category (e.g., 'productivity software', 'electric vehicles'). Used to auto-generate a relevant prompt set when you do not supply your own prompts below. Also informs recommendation context for GEO improvement suggestions. Ignored if 'prompts' is provided.
## `prompts` (type: `array`):

The exact questions your target audience asks AI engines (e.g., 'What is the best note-taking app?'). Provide your own list for precise tracking. If left empty, prompts are auto-generated from 'industry'. Each prompt is checked on every selected platform. Higher prompt variety produces richer recommendations.
## `platforms` (type: `array`):

Which AI answer engines to query. All engines run through OpenRouter using a single OPENROUTER_API_KEY (set as an environment variable). Default models: perplexity→perplexity/sonar, chatgpt→openai/gpt-4o-mini, claude→anthropic/claude-sonnet-4, gemini→google/gemini-2.5-flash. Override slugs via the 'models' field.
## `competitorBrands` (type: `array`):

Competitor brand names to track alongside yours (e.g., 'Evernote', 'Obsidian', 'Coda'). Used to compute your position ranking, share-of-voice, and to identify which competitors are outperforming you in AI visibility. The more competitors listed, the richer the comparison insights and recommendations.
## `competitorDomains` (type: `array`):

Competitor website domains for citation comparison (e.g., 'evernote.com', 'obsidian.md'). Used to detect when AI engines cite competitor sites but not yours — a key signal for GEO recommendations. Leave empty if you do not need domain-level citation gap analysis.
## `generateHtmlReport` (type: `boolean`):

When enabled, produces an agency-ready HTML report in the key-value store under REPORT. The report includes visibility score cards, per-platform breakdowns, position trends (if history exists), citation analysis, and top prioritized recommendations. Disable for MCP/API-only consumption to save runtime.
## `trackingId` (type: `string`):

Optional stable identifier used to store and compare history across scheduled runs. Defaults to a slug of the brand name. Use different IDs to track multiple brands independently. The history enables trend-based recommendations (e.g., 'visibility has dropped 3 weeks in a row — take action now').
## `useWebSearch` (type: `boolean`):

Enable live web search for models that support it via OpenRouter's web plugin (Perplexity Sonar already searches natively). Keep on for accurate AI-search visibility based on current web data. Turn off to test the models' built-in knowledge only.
## `webSearchResults` (type: `integer`):

How many web results the OpenRouter web plugin should fetch per query. More results produce richer answers with more citations but increase cost per query. Applies to non-native-search models (ChatGPT, Claude, Gemini).
## `models` (type: `object`):

Optional. Map each platform to a specific OpenRouter model slug for custom model selection. Example: {"chatgpt": "openai/gpt-4o", "claude": "anthropic/claude-sonnet-4"}. Any platform not listed uses its default model. Use when you want to test visibility across different model versions.
## `maxPrompts` (type: `integer`):

Safety cap on how many prompts are checked per run. Controls cost and runtime. Extra prompts beyond this limit are silently ignored. Higher values produce more granular recommendations but increase API cost.

## Actor input object example

```json
{
  "brandName": "Notion",
  "brandDomain": "notion.so",
  "industry": "productivity software",
  "prompts": [
    "What is the best note-taking and productivity app?",
    "Recommend the top productivity software for teams.",
    "Which all-in-one workspace tools are most popular?",
    "What tools do startups use for project management?"
  ],
  "platforms": [
    "perplexity",
    "chatgpt",
    "claude",
    "gemini"
  ],
  "competitorBrands": [
    "Evernote",
    "Obsidian",
    "Coda"
  ],
  "competitorDomains": [
    "evernote.com",
    "obsidian.md",
    "coda.io"
  ],
  "generateHtmlReport": true,
  "trackingId": "",
  "useWebSearch": true,
  "webSearchResults": 3,
  "models": {},
  "maxPrompts": 25
}
````

# Actor output Schema

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

Link to the dataset containing all prompt x engine visibility tracking rows.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "brandName": "Notion",
    "brandDomain": "notion.so",
    "industry": "productivity software",
    "prompts": [
        "What is the best note-taking and productivity app?",
        "Recommend the top productivity software for teams.",
        "Which all-in-one workspace tools are most popular?",
        "What tools do startups use for project management?"
    ],
    "competitorBrands": [
        "Evernote",
        "Obsidian",
        "Coda"
    ],
    "competitorDomains": [
        "evernote.com",
        "obsidian.md",
        "coda.io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/ai-geo-rec-tracker").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "brandName": "Notion",
    "brandDomain": "notion.so",
    "industry": "productivity software",
    "prompts": [
        "What is the best note-taking and productivity app?",
        "Recommend the top productivity software for teams.",
        "Which all-in-one workspace tools are most popular?",
        "What tools do startups use for project management?",
    ],
    "competitorBrands": [
        "Evernote",
        "Obsidian",
        "Coda",
    ],
    "competitorDomains": [
        "evernote.com",
        "obsidian.md",
        "coda.io",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/ai-geo-rec-tracker").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "brandName": "Notion",
  "brandDomain": "notion.so",
  "industry": "productivity software",
  "prompts": [
    "What is the best note-taking and productivity app?",
    "Recommend the top productivity software for teams.",
    "Which all-in-one workspace tools are most popular?",
    "What tools do startups use for project management?"
  ],
  "competitorBrands": [
    "Evernote",
    "Obsidian",
    "Coda"
  ],
  "competitorDomains": [
    "evernote.com",
    "obsidian.md",
    "coda.io"
  ]
}' |
apify call muhammadafzal/ai-geo-rec-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI GEO Recommendation Tracker",
        "description": "Track brand visibility across ChatGPT, Claude, Gemini and Perplexity with actionable GEO recommendations and agency-ready HTML reports.",
        "version": "1.0",
        "x-build-id": "clezoF4ysOwj1j74Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~ai-geo-rec-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-ai-geo-rec-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/muhammadafzal~ai-geo-rec-tracker/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-ai-geo-rec-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/muhammadafzal~ai-geo-rec-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-ai-geo-rec-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "brandName"
                ],
                "properties": {
                    "brandName": {
                        "title": "Brand Name",
                        "type": "string",
                        "description": "The brand, company, or product to track in AI answers (e.g., 'Notion', 'Tesla'). Used as the primary entity for mention detection, position ranking, share-of-voice computation, and recommendation generation.",
                        "default": "Notion"
                    },
                    "brandDomain": {
                        "title": "Brand Domain",
                        "type": "string",
                        "description": "Your brand's website domain (e.g., 'notion.so'). Used to detect when AI engines cite your site as a source and to compare citation rates against competitor domains. Leave empty to skip domain-based citation matching.",
                        "default": "notion.so"
                    },
                    "industry": {
                        "title": "Industry / Category",
                        "type": "string",
                        "description": "Your category (e.g., 'productivity software', 'electric vehicles'). Used to auto-generate a relevant prompt set when you do not supply your own prompts below. Also informs recommendation context for GEO improvement suggestions. Ignored if 'prompts' is provided.",
                        "default": "productivity software"
                    },
                    "prompts": {
                        "title": "Tracked Prompts",
                        "type": "array",
                        "description": "The exact questions your target audience asks AI engines (e.g., 'What is the best note-taking app?'). Provide your own list for precise tracking. If left empty, prompts are auto-generated from 'industry'. Each prompt is checked on every selected platform. Higher prompt variety produces richer recommendations.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "platforms": {
                        "title": "AI Platforms to Track",
                        "type": "array",
                        "description": "Which AI answer engines to query. All engines run through OpenRouter using a single OPENROUTER_API_KEY (set as an environment variable). Default models: perplexity→perplexity/sonar, chatgpt→openai/gpt-4o-mini, claude→anthropic/claude-sonnet-4, gemini→google/gemini-2.5-flash. Override slugs via the 'models' field.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "perplexity",
                            "chatgpt",
                            "claude",
                            "gemini"
                        ]
                    },
                    "competitorBrands": {
                        "title": "Competitor Brands",
                        "type": "array",
                        "description": "Competitor brand names to track alongside yours (e.g., 'Evernote', 'Obsidian', 'Coda'). Used to compute your position ranking, share-of-voice, and to identify which competitors are outperforming you in AI visibility. The more competitors listed, the richer the comparison insights and recommendations.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "competitorDomains": {
                        "title": "Competitor Domains",
                        "type": "array",
                        "description": "Competitor website domains for citation comparison (e.g., 'evernote.com', 'obsidian.md'). Used to detect when AI engines cite competitor sites but not yours — a key signal for GEO recommendations. Leave empty if you do not need domain-level citation gap analysis.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "generateHtmlReport": {
                        "title": "Generate HTML Report",
                        "type": "boolean",
                        "description": "When enabled, produces an agency-ready HTML report in the key-value store under REPORT. The report includes visibility score cards, per-platform breakdowns, position trends (if history exists), citation analysis, and top prioritized recommendations. Disable for MCP/API-only consumption to save runtime.",
                        "default": true
                    },
                    "trackingId": {
                        "title": "Tracking ID",
                        "type": "string",
                        "description": "Optional stable identifier used to store and compare history across scheduled runs. Defaults to a slug of the brand name. Use different IDs to track multiple brands independently. The history enables trend-based recommendations (e.g., 'visibility has dropped 3 weeks in a row — take action now').",
                        "default": ""
                    },
                    "useWebSearch": {
                        "title": "Use Web Search",
                        "type": "boolean",
                        "description": "Enable live web search for models that support it via OpenRouter's web plugin (Perplexity Sonar already searches natively). Keep on for accurate AI-search visibility based on current web data. Turn off to test the models' built-in knowledge only.",
                        "default": true
                    },
                    "webSearchResults": {
                        "title": "Web Search Results",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many web results the OpenRouter web plugin should fetch per query. More results produce richer answers with more citations but increase cost per query. Applies to non-native-search models (ChatGPT, Claude, Gemini).",
                        "default": 3
                    },
                    "models": {
                        "title": "Model Overrides",
                        "type": "object",
                        "description": "Optional. Map each platform to a specific OpenRouter model slug for custom model selection. Example: {\"chatgpt\": \"openai/gpt-4o\", \"claude\": \"anthropic/claude-sonnet-4\"}. Any platform not listed uses its default model. Use when you want to test visibility across different model versions.",
                        "default": {}
                    },
                    "maxPrompts": {
                        "title": "Max Prompts",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety cap on how many prompts are checked per run. Controls cost and runtime. Extra prompts beyond this limit are silently ignored. Higher values produce more granular recommendations but increase API cost.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
