# AI Visibility Rank Tracker — ChatGPT, Perplexity, Gemini (`muhammadafzal/ai-visibility-rank-tracker`) Actor

Track brand ranking and share-of-voice across ChatGPT, Perplexity, Claude, and Gemini over time. Monitors prompt sets, detects citations, scores sentiment, compares competitors, and reports run-over-run position changes. Schedule it for daily AI-search visibility tracking.

- **URL**: https://apify.com/muhammadafzal/ai-visibility-rank-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, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $60.00 / 1,000 prompt 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 Rank Tracker — ChatGPT, Perplexity, Claude & Gemini

Track how your brand ranks in AI answers over time. This actor queries **ChatGPT, Perplexity, Claude, and Gemini** with the prompts your customers actually ask, then measures whether your brand is mentioned, **where it ranks** versus competitors, its **share of voice**, whether your domain is **cited**, the **sentiment** of each mention — and how all of this **changes run over run**.

Built for Generative Engine Optimization (GEO): the new discipline of getting your brand recommended by AI answer engines. Schedule it daily or weekly to build a visibility history and catch ranking drops before they cost you traffic.

---

### What it does

For every **prompt × engine** combination, the actor returns a single clean row containing:

- **mentioned** — was your brand named in the answer?
- **position** — your rank by order of first appearance among all tracked brands (you + competitors)
- **share_of_voice** — your % of total tracked-brand mentions in the answer
- **cited / brand_cited_url** — was your domain referenced as a source?
- **citations** — the source URLs the answer relied on
- **sentiment** — positive / neutral / negative framing of your mention
- **competitors_mentioned** — which rivals showed up alongside you
- **position_change / visibility_status** — the delta versus the previous run (`new`, `gained`, `lost`, `improved`, `declined`, `unchanged`, `absent`)

A run-level rollup (visibility score, average position, share of voice, gained/lost counts, per-engine breakdown) is saved to the key-value store under `SUMMARY`.

Export results, run via API, schedule and monitor runs, or integrate with other tools.

---

### Why track AI visibility?

Buyers increasingly ask ChatGPT, Perplexity, Claude, and Gemini "what's the best tool for X?" instead of scrolling Google. If your brand isn't named — or is ranked below competitors — you lose the recommendation. Traditional SEO rank trackers don't see this. This actor does, across four engines, with trend history.

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `brandName` (required) | string | The brand/product to track. |
| `brandDomain` | string | Your domain (e.g., `notion.so`) for citation detection. |
| `industry` | string | Used to auto-generate prompts when you don't supply your own. |
| `prompts` | string[] | The exact questions to monitor. Falls back to auto-generated prompts from `industry`. |
| `platforms` | string[] | Any of `perplexity`, `chatgpt`, `claude`, `gemini`. |
| `competitors` | string[] | Competitor brands for position & share-of-voice. |
| `extractCitations` | boolean | Extract source URLs and detect domain citations. |
| `analyzeSentiment` | boolean | Classify the sentiment of each brand mention. |
| `trackingId` | string | Stable ID used to compare history across runs (defaults to a slug of the brand). |
| `useWebSearch` | boolean | Enable OpenRouter's web plugin for non-native-search models. |
| `webSearchResults` | integer | Web results per query for the plugin (1–10). |
| `models` | object | Optional per-platform OpenRouter model-slug overrides. |
| `maxPrompts` | integer | Cap on prompts per run (cost control). |

#### Example input

```json
{
  "brandName": "Notion",
  "brandDomain": "notion.so",
  "industry": "productivity software",
  "prompts": [
    "What is the best note-taking app for teams?",
    "Recommend an all-in-one workspace tool."
  ],
  "platforms": ["perplexity", "chatgpt", "claude", "gemini"],
  "competitors": ["Evernote", "Obsidian", "Coda"],
  "extractCitations": true,
  "analyzeSentiment": true
}
````

***

### API key (required) — one key for all models

All engines run through **[OpenRouter](https://openrouter.ai)**, so you only need a **single** API key. Set it as an environment variable on the actor (Console → Settings → Environment variables):

```
OPENROUTER_API_KEY = sk-or-...
```

If the key is missing, every check is reported with an `error` and **not charged**.

| Platform | Default model | Web search |
|----------|---------------|------------|
| Perplexity | `perplexity/sonar` | native |
| ChatGPT | `openai/gpt-4o-mini` | OpenRouter web plugin |
| Claude | `anthropic/claude-sonnet-4` | OpenRouter web plugin |
| Gemini | `google/gemini-2.5-flash` | OpenRouter web plugin |

> **Note:** For non-Perplexity models, web grounding uses OpenRouter's web plugin (it adds live search results to any model) rather than each vendor's own search product — the right trade-off for one-key simplicity, and it still reflects current web data. You pay OpenRouter directly for model + web-plugin usage; the actor's PPE events cover the tracking/analysis layer. Override any model slug with the `models` input.

***

### Output

Each row in the dataset:

```json
{
  "brand": "Notion",
  "brand_domain": "notion.so",
  "engine": "perplexity",
  "model_used": "sonar",
  "prompt": "What is the best note-taking app for teams?",
  "mentioned": true,
  "position": 1,
  "share_of_voice": 60,
  "cited": true,
  "citations": ["https://notion.so/product", "https://example.com/review"],
  "brand_cited_url": "https://notion.so/product",
  "mention_count": 2,
  "mention_context": "Notion is one of the most popular all-in-one workspaces...",
  "sentiment": "positive",
  "competitors_mentioned": ["Evernote", "Obsidian"],
  "previous_mentioned": true,
  "previous_position": 3,
  "position_change": 2,
  "visibility_status": "improved",
  "error": null,
  "checked_at": "2026-06-07T12:00:00.000Z"
}
```

***

### Pricing (Pay Per Event)

Charged events:

| Event | When |
|-------|------|
| `actor-start` | Once per run. |
| `prompt-engine-check` | Each successful prompt × engine check. |
| `citation-extraction` | Each successful check when citation extraction is enabled. |
| `sentiment-analysis` | Each mention scored when sentiment analysis is enabled. |

Failed checks (e.g., a missing API key) are **never charged**. You pay your own LLM provider for the underlying API calls.

***

### Scheduling for trend tracking

1. Run once to seed a baseline (first run shows `visibility_status: new` / `absent`).
2. Create a Schedule (daily or weekly) with the same `trackingId`.
3. Each run compares against the previous snapshot and fills `position_change` and `visibility_status`.

History is stored in a named key-value store (`ai-rank-history-<trackingId>`), so multiple brands can be tracked independently.

***

### Use cases

- **GEO / AEO monitoring** — prove and improve how AI engines recommend you.
- **Competitive intelligence** — see who AI names ahead of you, and where.
- **Content ROI** — confirm whether new content gets you cited.
- **Agency reporting** — deliver weekly AI-visibility reports to clients.

***

### Notes

- Results depend on each engine's live web access and model behavior; answers vary between runs, which is exactly what trend tracking is for.
- Keep prompts stable across runs for the cleanest deltas.

# Actor input Schema

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

The brand, company, or product to track in AI answers (e.g., 'Notion', 'Tesla'). This is the primary entity scored for visibility, position, and share-of-voice.

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

Your brand's website domain (e.g., 'notion.so'). Used to detect when an AI engine cites your site as a source. Leave empty to skip citation-by-domain matching.

## `industry` (type: `string`):

Your category (e.g., 'productivity software', 'electric vehicles'). Used ONLY to auto-generate a sensible prompt set when you do not supply your own prompts below. Ignored if 'prompts' is provided.

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

The exact questions your buyers ask 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.

## `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). Defaults: 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.

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

Competitor brand names to compare against (e.g., 'Evernote', 'Obsidian'). Used to compute your position (rank order) and share-of-voice within each AI answer.

## `extractCitations` (type: `boolean`):

Enable to extract the source URLs each AI answer references and flag whether your domain is cited. Adds a per-check charge.

## `analyzeSentiment` (type: `boolean`):

Enable to classify the sentiment (positive / neutral / negative) of how your brand is mentioned. Adds a per-mention charge.

## `trackingId` (type: `string`):

Optional stable identifier used to store and compare history across scheduled runs. Defaults to a slug of the brand name. Use distinct IDs to track multiple brands separately.

## `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; 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 = richer answers but higher cost). Applies to non-native-search models.

## `models` (type: `object`):

Optional. Map each platform to a specific OpenRouter model slug, e.g. {"chatgpt": "openai/gpt-4o", "claude": "anthropic/claude-sonnet-4"}. Any platform not listed uses its default model.

## `maxPrompts` (type: `integer`):

Safety cap on how many prompts are checked per run (controls cost). Extra prompts beyond this limit are ignored.

## 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?"
  ],
  "platforms": [
    "perplexity",
    "chatgpt",
    "claude",
    "gemini"
  ],
  "competitors": [
    "Evernote",
    "Obsidian",
    "Coda"
  ],
  "extractCitations": true,
  "analyzeSentiment": 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?"
    ],
    "competitors": [
        "Evernote",
        "Obsidian",
        "Coda"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/ai-visibility-rank-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?",
    ],
    "competitors": [
        "Evernote",
        "Obsidian",
        "Coda",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/ai-visibility-rank-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?"
  ],
  "competitors": [
    "Evernote",
    "Obsidian",
    "Coda"
  ]
}' |
apify call muhammadafzal/ai-visibility-rank-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Visibility Rank Tracker — ChatGPT, Perplexity, Gemini",
        "description": "Track brand ranking and share-of-voice across ChatGPT, Perplexity, Claude, and Gemini over time. Monitors prompt sets, detects citations, scores sentiment, compares competitors, and reports run-over-run position changes. Schedule it for daily AI-search visibility tracking.",
        "version": "1.0",
        "x-build-id": "0GR7NVCyynIaHRdRo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~ai-visibility-rank-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-ai-visibility-rank-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-visibility-rank-tracker/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-ai-visibility-rank-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-visibility-rank-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-ai-visibility-rank-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'). This is the primary entity scored for visibility, position, and share-of-voice.",
                        "default": "Notion"
                    },
                    "brandDomain": {
                        "title": "Brand Domain",
                        "type": "string",
                        "description": "Your brand's website domain (e.g., 'notion.so'). Used to detect when an AI engine cites your site as a source. Leave empty to skip citation-by-domain matching.",
                        "default": "notion.so"
                    },
                    "industry": {
                        "title": "Industry / Category",
                        "type": "string",
                        "description": "Your category (e.g., 'productivity software', 'electric vehicles'). Used ONLY to auto-generate a sensible prompt set when you do not supply your own prompts below. Ignored if 'prompts' is provided.",
                        "default": "productivity software"
                    },
                    "prompts": {
                        "title": "Tracked Prompts",
                        "type": "array",
                        "description": "The exact questions your buyers ask 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.",
                        "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). Defaults: 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"
                        ]
                    },
                    "competitors": {
                        "title": "Competitor Brands",
                        "type": "array",
                        "description": "Competitor brand names to compare against (e.g., 'Evernote', 'Obsidian'). Used to compute your position (rank order) and share-of-voice within each AI answer.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "extractCitations": {
                        "title": "Add-on: Extract Citations",
                        "type": "boolean",
                        "description": "Enable to extract the source URLs each AI answer references and flag whether your domain is cited. Adds a per-check charge.",
                        "default": true
                    },
                    "analyzeSentiment": {
                        "title": "Add-on: Analyze Sentiment",
                        "type": "boolean",
                        "description": "Enable to classify the sentiment (positive / neutral / negative) of how your brand is mentioned. Adds a per-mention charge.",
                        "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 distinct IDs to track multiple brands separately.",
                        "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; 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 = richer answers but higher cost). Applies to non-native-search models.",
                        "default": 3
                    },
                    "models": {
                        "title": "Model Overrides",
                        "type": "object",
                        "description": "Optional. Map each platform to a specific OpenRouter model slug, e.g. {\"chatgpt\": \"openai/gpt-4o\", \"claude\": \"anthropic/claude-sonnet-4\"}. Any platform not listed uses its default model.",
                        "default": {}
                    },
                    "maxPrompts": {
                        "title": "Max Prompts",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety cap on how many prompts are checked per run (controls cost). Extra prompts beyond this limit are ignored.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
