# AI Rank Tracker - ChatGPT, Perplexity & Gemini (`khadinakbar/ai-rank-tracker`) Actor

Track where a brand, product, company, or domain ranks inside AI answer shortlists across Perplexity, ChatGPT, Gemini, and optional Claude. Use for SEO/GEO reporting, not Google SERP tracking. Returns targetRank, rankBucket, rankedEntities, competitorRanks, citations. $0.10/row.

- **URL**: https://apify.com/khadinakbar/ai-rank-tracker.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 ai rank 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 Rank Tracker - Track Brand Positions in AI Answers

AI Rank Tracker checks where a brand, product, company, tool, or domain appears inside AI answer rankings. It submits bounded ranking prompts to Perplexity, ChatGPT, Gemini, and optional Claude, then returns one record per prompt x platform with target rank, top ranked entities, competitor ranks, citations, source domains, and an AI rank score.

Use it when you need dated evidence for GEO, AEO, and AI-search reporting: "Where does my brand rank when buyers ask AI for the best tools in my category?" Do not use it for classic Google SERP rank tracking, raw Google AI Overview extraction, or website crawlability audits.

### Output Fields

| Field | Description |
| --- | --- |
| `platform` | AI answer engine checked: Perplexity, ChatGPT, Gemini, or Claude |
| `query` | Exact ranking prompt submitted to the AI platform |
| `targetRank` | Detected target position in the AI answer shortlist; null when not ranked |
| `rankBucket` | `rank_1`, `top_3`, `top_10`, `mentioned_unranked`, or `not_found` |
| `aiRankScore` | 0-100 score derived from rank, share of voice, and owned-domain citation |
| `rankedEntities` | Top entities detected from the answer's ranked list or fallback mention order |
| `winningEntity` | First-ranked entity detected in the answer |
| `competitorRanks` | Rank positions for the competitors you supplied |
| `targetShareOfVoice` | Target mentions divided by target plus competitor mentions |
| `domainCited` | Whether the target domain was cited as a source |
| `citedUrls` | Source URLs extracted from citations, annotations, grounding, or links |
| `sourceDomains` | Deduplicated domains cited by the AI response |
| `aiAnswerExcerpt` | Concise or detailed answer excerpt for review |

### Pricing

This actor uses Pay per event + usage. Event charges are `$0.10` per successful AI rank check, where one check is one prompt on one AI platform. Apify platform usage is charged separately by Apify.

| Example run | Event charges |
| --- | ---: |
| 1 prompt x 1 platform | `$0.10` |
| 3 prompts x 3 default platforms | `$0.90` |
| 5 prompts x 4 platforms including Claude | `$2.00` |

The actor prints the maximum event-charge cap before it calls any AI provider. Failed provider calls are not billed as rank rows.

### Input

```json
{
  "targetName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools",
  "competitors": ["Bright Data", "Octoparse"],
  "queryTemplates": ["recommendations", "alternatives", "category_leaders"],
  "platforms": ["perplexity", "chatgpt", "gemini"],
  "maxQueries": 3,
  "maxRankedEntities": 10,
  "responseFormat": "concise"
}
````

`targetName` is required. `targetDomain` is optional but recommended because it enables owned-domain citation tracking. Claude is available when selected explicitly; it is not part of the default platform set to keep typical runs under agent-payment budgets.

### Output Example

```json
{
  "platform": "perplexity",
  "query": "Rank the best web scraping tools for agencies.",
  "targetName": "Apify",
  "targetDomain": "apify.com",
  "targetMentioned": true,
  "targetMentionCount": 2,
  "targetMentionPosition": 1,
  "targetRank": 1,
  "rankBucket": "rank_1",
  "aiRankScore": 96,
  "targetShareOfVoice": 0.5,
  "sentiment": "positive",
  "domainCited": true,
  "citedUrl": "https://apify.com/store",
  "rankedEntities": ["Apify", "Bright Data", "Octoparse"],
  "rankedEntityCount": 3,
  "winningEntity": "Apify",
  "competitorRanks": [{"entity": "Bright Data", "rank": 2}],
  "sourceDomains": ["apify.com"],
  "modelUsed": "perplexity/sonar",
  "checkedAt": "2026-07-14T18:00:00.000Z"
}
```

Compact `OUTPUT` and detailed `RUN_SUMMARY` records are also written to the key-value store. The summary includes ranked rate, average target rank, AI rank score, platform scores, top source domains, top competitors, provider diagnostics, event charges, and recommendations.

### API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~ai-rank-tracker/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targetName": "Apify",
    "targetDomain": "apify.com",
    "industry": "web scraping tools",
    "competitors": ["Bright Data", "Octoparse"],
    "platforms": ["perplexity", "chatgpt", "gemini"],
    "maxQueries": 3
  }'
```

### MCP And Agent Use

Through the Apify MCP Server, this actor is useful for questions like:

- "Check where Apify ranks in AI answers for web scraping tool prompts."
- "Compare my AI rank against these competitors across ChatGPT, Perplexity, and Gemini."
- "Which sources do AI answers cite when ranking my category?"

The actor returns a flat, schema-declared dataset so agents can page results, filter by platform, compare rank buckets, and summarize the `RUN_SUMMARY` KV record.

### Limits And Reliability Notes

AI answer engines change outputs frequently. Treat each run as a dated sample, not a permanent ranking guarantee. The actor records the model used and `checkedAt` timestamp so recurring runs can be compared over time.

Rank extraction prefers explicit numbered lists, bullet lists, headings, and simple tables. When an answer is prose instead of a clean shortlist, the actor falls back to mention order among the target and supplied competitors. Rows expose both `targetRank` and `rankedEntities` so you can inspect the evidence.

Provider calls require owner-managed `OPENROUTER_API_KEY`; native Gemini uses `GEMINI_API_KEY` when available and falls back to OpenRouter Gemini online when possible. If a required provider is unavailable and no useful rows are produced, the actor fails honestly with `UPSTREAM_FAILED` or `CONFIG_ERROR` and writes `OUTPUT` plus `RUN_SUMMARY`.

### Related Actors

Use [AI Search Brand Monitor](https://apify.com/khadinakbar/ai-search-brand-monitor) when you want the older brand-monitoring contract focused on mention trends and GEO recommendations.

Use [AI Search Visibility Tracker](https://apify.com/khadinakbar/ai-search-visibility-tracker) when the job is domain citation tracking for topic keywords and the brand name itself is secondary.

Use [AI Overviews Tracker](https://apify.com/khadinakbar/ai-overviews-tracker) when the target is Google AI Overview-specific visibility rather than multi-engine AI answers.

### Legal And Data Use

This actor queries AI provider APIs and records generated answer excerpts, citation URLs, and derived rank metrics. Review provider terms and your organization's policies before using outputs in public reports. Do not submit private customer data, secrets, or personal information in prompts.

# Actor input Schema

## `targetName` (type: `string`):

Use this when you want to track one brand, product, company, tool, or domain in AI answer rankings. Enter the public name exactly as buyers write it, for example "Apify". Required for real scans and prefilled for testing. Not a competitor list; put rivals in competitors.

## `targetDomain` (type: `string`):

Use this when citation tracking should detect the target website. Enter a bare domain such as "apify.com" or a URL like "https://apify.com". Defaults to blank, which skips owned-domain citation checks but still tracks rank. Not a list of pages.

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

Use this when built-in ranking prompts should include the market category. Enter a short phrase such as "web scraping tools" or "CRM software". Defaults to "software tools" when blank. Not a keyword list; use queries for exact prompts.

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

Use this when you want competitor rank positions and share-of-voice. Enter brand names or domains, for example \["Bright Data", "Octoparse"]. Defaults to an empty list and accepts up to 10 values. Not the tracked target; use targetName for that.

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

Use this when you have exact AI-ranking questions to test. Enter one prompt per line, for example "Rank the best web scraping tools for agencies". Defaults to empty, so the actor generates prompts from queryTemplates. Not Google keywords; these are full prompts sent to AI platforms.

## `queryTemplates` (type: `array`):

Use this when you want standard buyer-intent ranking prompt categories. Defaults to recommendations, alternatives, and category\_leaders. Choose from the listed values; maxQueries caps the final unique prompt count. Not used to rewrite custom prompts.

## `platforms` (type: `array`):

Use this to choose which AI answer engines to check. Defaults to \["perplexity", "chatgpt", "gemini"] for bounded cost. Add "claude" only when you explicitly need a deeper audit; Claude is token-capped. Not a model-id field.

## `maxQueries` (type: `integer`):

Use this to cap unique prompts before multiplying by selected platforms. Defaults to 3, so the normal 3-platform run costs about $0.90 in event charges. Minimum 1 and maximum 10. Not the ranked-entity cap; each prompt x platform can create one row.

## `maxRankedEntities` (type: `integer`):

Use this to limit how many ranked entities are stored from each AI answer. Defaults to 10, which keeps MCP previews compact while preserving top-list context. Minimum 3 and maximum 20. Not the number of prompts or platforms.

## `responseFormat` (type: `string`):

Use this to control how much AI-answer text is stored in each row. Defaults to "concise" for MCP and agent workflows. Choose "detailed" when a human will inspect answer context. Not a platform selector.

## `webhookUrl` (type: `string`):

Use this when another system should receive the run summary after completion. Enter an HTTPS endpoint such as "https://hooks.zapier.com/hooks/catch/...". Defaults to blank, so no webhook is sent. Not used for authentication or API keys.

## `demoMode` (type: `boolean`):

Use this when you want a no-charge connectivity check. When true, the actor writes OUTPUT and RUN\_SUMMARY without calling AI providers. Defaults to false for real scans. Not a cached rank report.

## Actor input object example

```json
{
  "targetName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools",
  "competitors": [
    "Bright Data",
    "Octoparse"
  ],
  "queries": [
    "Rank the best web scraping tools for agencies",
    "What are the top alternatives to Apify?"
  ],
  "queryTemplates": [
    "recommendations",
    "alternatives",
    "category_leaders"
  ],
  "platforms": [
    "perplexity",
    "chatgpt",
    "gemini"
  ],
  "maxQueries": 3,
  "maxRankedEntities": 10,
  "responseFormat": "concise",
  "webhookUrl": "https://hooks.zapier.com/hooks/catch/123/abc",
  "demoMode": false
}
```

# Actor output Schema

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

Dataset items, one per successful prompt x platform rank check.

## `output` (type: `string`):

Stable compact machine-readable outcome contract.

## `runSummary` (type: `string`):

Detailed diagnostics, rank metrics, provider attempts, platform scores, recommendations, charges, and warnings.

# 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 = {
    "targetName": "Apify",
    "targetDomain": "apify.com",
    "industry": "web scraping tools"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/ai-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 = {
    "targetName": "Apify",
    "targetDomain": "apify.com",
    "industry": "web scraping tools",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/ai-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 '{
  "targetName": "Apify",
  "targetDomain": "apify.com",
  "industry": "web scraping tools"
}' |
apify call khadinakbar/ai-rank-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Rank Tracker - ChatGPT, Perplexity & Gemini",
        "description": "Track where a brand, product, company, or domain ranks inside AI answer shortlists across Perplexity, ChatGPT, Gemini, and optional Claude. Use for SEO/GEO reporting, not Google SERP tracking. Returns targetRank, rankBucket, rankedEntities, competitorRanks, citations. $0.10/row.",
        "version": "1.1",
        "x-build-id": "w0gqzhYVF8qAzd6GE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~ai-rank-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-ai-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/khadinakbar~ai-rank-tracker/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-ai-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/khadinakbar~ai-rank-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-ai-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": [
                    "targetName"
                ],
                "properties": {
                    "targetName": {
                        "title": "Target name",
                        "type": "string",
                        "description": "Use this when you want to track one brand, product, company, tool, or domain in AI answer rankings. Enter the public name exactly as buyers write it, for example \"Apify\". Required for real scans and prefilled for testing. Not a competitor list; put rivals in competitors."
                    },
                    "targetDomain": {
                        "title": "Target domain",
                        "type": "string",
                        "description": "Use this when citation tracking should detect the target website. Enter a bare domain such as \"apify.com\" or a URL like \"https://apify.com\". Defaults to blank, which skips owned-domain citation checks but still tracks rank. Not a list of pages.",
                        "default": ""
                    },
                    "industry": {
                        "title": "Industry or category",
                        "type": "string",
                        "description": "Use this when built-in ranking prompts should include the market category. Enter a short phrase such as \"web scraping tools\" or \"CRM software\". Defaults to \"software tools\" when blank. Not a keyword list; use queries for exact prompts.",
                        "default": "software tools"
                    },
                    "competitors": {
                        "title": "Competitors",
                        "type": "array",
                        "description": "Use this when you want competitor rank positions and share-of-voice. Enter brand names or domains, for example [\"Bright Data\", \"Octoparse\"]. Defaults to an empty list and accepts up to 10 values. Not the tracked target; use targetName for that.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "queries": {
                        "title": "Custom ranking prompts",
                        "type": "array",
                        "description": "Use this when you have exact AI-ranking questions to test. Enter one prompt per line, for example \"Rank the best web scraping tools for agencies\". Defaults to empty, so the actor generates prompts from queryTemplates. Not Google keywords; these are full prompts sent to AI platforms.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "queryTemplates": {
                        "title": "Query templates",
                        "type": "array",
                        "description": "Use this when you want standard buyer-intent ranking prompt categories. Defaults to recommendations, alternatives, and category_leaders. Choose from the listed values; maxQueries caps the final unique prompt count. Not used to rewrite custom prompts.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "recommendations",
                                "alternatives",
                                "category_leaders",
                                "reviews",
                                "comparisons"
                            ],
                            "enumTitles": [
                                "Recommendations",
                                "Alternatives",
                                "Category leaders",
                                "Reviews",
                                "Comparisons"
                            ]
                        },
                        "default": [
                            "recommendations",
                            "alternatives",
                            "category_leaders"
                        ]
                    },
                    "platforms": {
                        "title": "AI platforms",
                        "type": "array",
                        "description": "Use this to choose which AI answer engines to check. Defaults to [\"perplexity\", \"chatgpt\", \"gemini\"] for bounded cost. Add \"claude\" only when you explicitly need a deeper audit; Claude is token-capped. Not a model-id field.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "perplexity",
                                "chatgpt",
                                "gemini",
                                "claude"
                            ],
                            "enumTitles": [
                                "Perplexity",
                                "ChatGPT",
                                "Gemini",
                                "Claude"
                            ]
                        },
                        "default": [
                            "perplexity",
                            "chatgpt",
                            "gemini"
                        ]
                    },
                    "maxQueries": {
                        "title": "Max prompts to run",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Use this to cap unique prompts before multiplying by selected platforms. Defaults to 3, so the normal 3-platform run costs about $0.90 in event charges. Minimum 1 and maximum 10. Not the ranked-entity cap; each prompt x platform can create one row.",
                        "default": 3
                    },
                    "maxRankedEntities": {
                        "title": "Max ranked entities per row",
                        "minimum": 3,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Use this to limit how many ranked entities are stored from each AI answer. Defaults to 10, which keeps MCP previews compact while preserving top-list context. Minimum 3 and maximum 20. Not the number of prompts or platforms.",
                        "default": 10
                    },
                    "responseFormat": {
                        "title": "Response format",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use this to control how much AI-answer text is stored in each row. Defaults to \"concise\" for MCP and agent workflows. Choose \"detailed\" when a human will inspect answer context. Not a platform selector.",
                        "default": "concise"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Use this when another system should receive the run summary after completion. Enter an HTTPS endpoint such as \"https://hooks.zapier.com/hooks/catch/...\". Defaults to blank, so no webhook is sent. Not used for authentication or API keys.",
                        "default": ""
                    },
                    "demoMode": {
                        "title": "Demo mode",
                        "type": "boolean",
                        "description": "Use this when you want a no-charge connectivity check. When true, the actor writes OUTPUT and RUN_SUMMARY without calling AI providers. Defaults to false for real scans. Not a cached rank report.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
