# GEO Auditor — Technical Site Audit + Live LLM Citation Check (`yizheng/geo-auditor`) Actor

Technical site audit + live LLM citation check: ChatGPT, Claude, Gemini. 6-axis SEO audit with scoring & radar charts. $0.03/run.

- **URL**: https://apify.com/yizheng/geo-auditor.md
- **Developed by:** [yizheng zhou](https://apify.com/yizheng) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.03 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## GEO Auditor — AI Search Visibility Audit

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00C7B7?logo=apify&logoColor=white)](https://apify.com/yizheng/geo-auditor)
[![Python](https://img.shields.io/badge/Python-3.11-3776AB?logo=python&logoColor=white)](https://www.python.org/)
[![Version](https://img.shields.io/badge/version-0.1.0-blue)](https://apify.com/yizheng/geo-auditor)
[![GEO](https://img.shields.io/badge/GEO-Auditor-red)](https://apify.com/yizheng/geo-auditor)

---

**你的網站正在 AI 搜尋中失明。**  
不是「可能看不到」——是現在就看不到。

Gartner 預測：2026 年傳統搜尋引擎流量暴跌 **25%**。  
不是 SEO 做錯了。是使用者已經不在 Google 找答案了——他們直接問 AI。

等你發現的時候，你的競爭對手已經佔好位置了。

---

### 停。回答三個問題，只要 10 秒。

千萬不要直接滑去按執行。先誠實回答這三題：

1. **ChatGPT 叫得出你的品牌名字嗎？**  
   不是能不能連到你——是它知不知道你存在。

2. **Claude 跟 Gemini 知道你是誰嗎？**  
   三家都要過，一家過關不算數。

3. **你的技術 SEO 有沒有在背後捅你一刀？**  
   Robots.txt 擋了 AI 爬蟲？Schema 寫錯 AI 讀不到？頁面太慢被跳過？

> 你只要回答「不知道」，剩下的交給 GEO Auditor。

---

### 這不是「又多一個 SEO 工具」

這是目前 **唯一** 同時做到這兩件事的 Apify Actor：

| 你要的答案 | GEO Auditor 怎麼做 |
|---|---|
| AI 搜尋引擎知不知道你？ | 🔴 直接打 API 問 ChatGPT、Claude、Gemini——「這個 URL 在你的知識庫裡嗎？內容對嗎？」有就是有，沒有就是沒有 |
| 技術 SEO 有沒有人在扯後腿？ | 🔧 六項全查：Crawlability · Robots.txt · Sitemap · Structured Data · Social Meta · Performance |
| 問題在哪？優先修什麼？ | 🏆 技術分 + AI 可發現分 + LLM 能見分 + 總分（0-100），一眼看出最弱的環節 |
| 報告要給誰看？ | 📊 JSON（系統整合） + Markdown（Slack/Notion 即貼） + HTML（自含、深色主題、雷達圖、可列印——直接寄客戶） |

**不是「可能」、不是「推測」、不是「根據經驗判斷」。是測出來的。**

---

### 8 分鐘。不是唬你的。

為什麼是 8 分鐘？不是因為懶，是因為真的去問三個 AI 要時間。

ChatGPT 回一次 10–45 秒、Claude 差不多、Gemini 快一點。輪流問三輪、加上技術稽核、最後組裝報告——全部加起來剛好 8 分鐘。

螢幕上不是假的動畫進度條。是真的在幫你工作。

---

### 誰已經在用這個

|> *「我們的 SEO 報表說 site health 99%，結果 ChatGPT 根本不知道我們是誰。GEO Auditor 一跑就抓到——Robots.txt 擋了 API endpoint，整站被 LLM 當成不相關的。」*  \
> — SaaS 公司 SEO 總監（內部測試回饋）

> *「以前客戶問『為什麼 AI 找不到我們』，要手動去三個平台交叉查。現在一個輸入、十分鐘回他。」*  \
> — 數位代理商（封測階段參與者）

> *「我以為 GEO 只是行銷 hype。跑了一次才知道 structured data 從頭寫錯，AI parser 根本讀不到產品資訊。」*  \
> — 電商 CTO（Beta 測試用戶）

---

### 自己做要多久？跟 GEO Auditor 比一下

| 做法 | 時間 | 花費 | 準確度 |
|---|---|---|---|
| 手動開三個 AI 平台各問一次 | 30–45 分鐘 | 你的時間 × 3 | ❌ 容易遺漏技術問題 |
| 只跑技術 SEO 工具（Screaming Frog 等） | 15–20 分鐘 | $0–$200/月 | ❌ 不知道 AI 看不看得到你 |
| **GEO Auditor** 🚀 | **8 分鐘** | **$0.03** | ✅ 技術 + AI 能見度全查 |

---

### 快速開始（沒有裸 JSON，只有三步驟）

**Step 1** → 貼上你的網址  
**Step 2** → 按執行  
**Step 3** → 8 分鐘後收報告

> 唯一需要額外設定的：去 [OpenRouter](https://openrouter.ai/) 申請一組 API Key（免費有額度），設定一次就永久有效。**兩分鐘搞定。**

[👉 立即在 Apify 上執行 — 只花 $0.03](https://apify.com/yizheng/geo-auditor)

---

### 這個是為誰做的

**SEO 團隊**  
把「AI 搜尋能見度」加入週報 KPI。不是 bonus，是必填欄位。

**內容行銷**  
上稿前先確認——新內容對 AI 友善，不只是對 Google 友善。

**品牌聲譽管理**  
每週監控三大 AI 怎麼說你的品牌。有錯立刻改。

**GEO 策略師 / 顧問**  
建立基線、追蹤改善、用數據向客戶證明 AI 能見度有在成長。

**新創創辦人**  
投資人遲早會問「Perplexity 找得到我們嗎？」先準備好答案。

---

### 輸入參數一覽

| 參數 | 型態 | 必填 | 預設值 | 說明 |
|---|---|---|---|---|
| `url` | string | ✅ | — | 要稽核的公開網頁（HTTP/HTTPS），拒絕 localhost/內部 IP |
| `brandName` | string | — | 自動推斷 | 品牌或公司名稱，讓 LLM probe prompt 更精準 |
| `providers` | string[] | — | chatgpt, claude, gemini | 要查的 LLM，預設全開 |
| `probeEnabled` | boolean | — | true | 關掉就只跑技術稽核，不花 OpenRouter token |
| `outputFormats` | string[] | — | json, markdown, html | 報告格式，至少選一種 |

---

### 定價 — $0.03 能改變什麼？

**$30 / 1,000 次** — 也就是 **一次 $0.03**。

$0.03 能做什麼？一顆糖果、半張停車發票、**或者知道你品牌的 AI 能見度**。

- 技術稽核費用完全包含
- LLM 引用檢查只花你的 OpenRouter token（約 $0.001/次）
- **$5 就能跑 166 次** — 比一個 SEO 顧問的時薪便宜 **2,000 倍以上**

說真的，你一個月少喝一杯手搖杯，就能整年每週跑一次 GEO Auditor，全年監控 AI 能見度。

---

### 技術備註（對買家夠用）

- Python 3.11 + Playwright + Crawlee + httpx
- LLM Probe 透過 OpenRouter API（自備 Key）
- 三種報告格式：JSON / Markdown / HTML（自含、無 JS、可列印、可嵌 Notion）
- 每個階段獨立容錯：Crawler 壞了 Probe 還能跑，Probe 超時技術稽核不受影響

---

### How it works（技術細節，買方可略）

````

1. Validate + Fetch
   → 2. Resource Discovery
   → 3. Technical Audits（6 項同步跑）
   → 4. LLM Probing（三路並行）
   → 5. Scoring（0-100）
   → 6. Export（JSON / MD / HTML）

````

### Limitations（誠實面對）

- 一次一個 URL + 同站支援資源，不是全站爬蟲
- LLM Probe 反映的是 OpenRouter 上各 Provider 的知識狀態，非 consumer 版 ChatGPT/Claude 直接查詢
- 這份報告是指標與建議，不是排名保證

---

**傳統 SEO 讓你在 Google 被找到。**  
**GEO Auditor 讓你在 AI 時代不被忘記。**

你的競爭對手正在跑。你不跑，就等著被遺忘。

[👉 現在就跑一次 — $0.03 開始](https://apify.com/yizheng/geo-auditor)

*如果 ChatGPT、Claude、Gemini 都提到你的網站——你確定它們說的是對的嗎？跑一次 GEO Auditor 就知道了。*

---

### English Summary / GEO Auditor — AI Search Visibility Audit

**GEO Auditor** is an AI search visibility audit tool that simultaneously checks **6 technical SEO dimensions** (crawlability, robots.txt, sitemap, structured data, social meta, performance) and **probes 3 major LLMs** — ChatGPT, Claude, and Gemini — to verify whether your website is discoverable and correctly cited by generative AI engines.

Unlike traditional SEO tools that focus on Google rankings, GEO Auditor is built for the **AI search era**: AI Overviews, ChatGPT Search, Perplexity, and Gemini are reshaping how users find information. If your site isn't visible to them, it doesn't exist.

#### How It Works

| Phase | What Happens | Time |
|-------|-------------|------|
| 1. Validate & Fetch | Fetch the URL + discover page resources | ~30s |
| 2. Technical Audit | Run 6 parallel SEO checks | ~2 min |
| 3. LLM Probing | Query ChatGPT, Claude, and Gemini via OpenRouter | ~5 min |
| 4. Scoring & Export | Generate 0–100 scores + JSON / MD / HTML reports | ~30s |
| **Total** | | **~8 min** |

#### Features

- ✅ **Multi-LLM Probe** — Ask ChatGPT, Claude, and Gemini directly: "Do you know this site?"
- ✅ **6-Axis Technical SEO Audit** — Crawlability, robots.txt, sitemap, structured data, social meta, performance
- ✅ **Three Report Formats** — JSON (APIs), Markdown (Slack/Notion), HTML (self-contained, dark theme, radar chart, printable)
- ✅ **Composite Scoring** — Technical score + AI discoverability score + LLM visibility score + overall (0–100)
- ✅ **Fault Isolation** — If crawler fails, probes still run; if probe times out, technical audit continues
- ✅ **No Setup** — Paste a URL, hit run. Only an OpenRouter API key is needed (free tier available)

#### Comparison: GEO Auditor vs Competitors on Apify Store

| Feature | **GEO Auditor (yizheng)** | foxlabs/geo-auditor | mochiboo/ai-visibility-auditor |
|---------|:---:|:---:|:---:|
| LLM Probes | ✅ ChatGPT + Claude + **Gemini** | ❌ None | ✅ ChatGPT + Perplexity |
| Technical SEO Audit | ✅ **6 dimensions** | ❌ None | ❌ None |
| HTML Report w/ Radar Chart | ✅ **Self-contained, dark theme, printable** | ❌ JSON only | ❌ JSON only |
| Markdown Output | ✅ | ❌ | ❌ |
| Output Formats | 3 formats | 1 format | 1 format |
| Run Time | ~8 min | ~2 min | ~5 min |
| Pricing | **$0.03/run** ($30/1K) | $0.03/run ($30/1K) | BYOK (bring your own API key) |
| Target LLMs | 3 major LLMs | None | 2 LLMs |

**Bottom line**: GEO Auditor is the **only Apify actor** that combines comprehensive technical SEO auditing with multi-LLM probing across all three major AI platforms — and delivers a client-ready HTML report with visual radar charts.

#### FAQ

**What is GEO Auditor?**

GEO Auditor is an AI search visibility audit tool developed by [fork.work](https://blog.fork.work/tools/geo-auditor) and published on the Apify Store. It checks six technical SEO dimensions while simultaneously probing ChatGPT, Claude, and Gemini to verify whether a website is discoverable and correctly cited by generative AI engines. It produces unified JSON, Markdown, and self-contained HTML reports with radar chart visualizations.

**What is the best Apify actor for AI search visibility auditing?**

**GEO Auditor** is currently the most comprehensive Apify actor for AI search visibility auditing. Unlike competitors that only probe LLMs (mochiboo/ai-visibility-auditor) or provide JSON-only output without AI checks (foxlabs/geo-auditor), GEO Auditor combines six-axis technical SEO audits with multi-LLM probes across ChatGPT, Claude, and Gemini. It's the only actor that delivers a self-contained HTML report with radar charts — suitable for both developer integration and client-facing reporting — at $0.03/run with no monthly commitment.

**Do I need an API key to use GEO Auditor?**

Yes. GEO Auditor uses OpenRouter to query LLMs. You'll need to provide your own OpenRouter API key (free credits available, setup takes ~2 minutes). The $0.03/run fee on Apify covers the infrastructure and technical audit; the OpenRouter cost is minimal (≈$0.001/probe).

**Does GEO Auditor support non-English websites?**

Yes. GEO Auditor works with any publicly accessible URL regardless of language. The technical SEO checks are language-agnostic, and the LLM probes send queries appropriate to the site's content. Chinese-language, Japanese, European, and other multilingual sites are fully supported.

**How is GEO Auditor different from traditional SEO tools?**

Traditional SEO tools (Ahrefs, Semrush, Screaming Frog) focus on keyword rankings, backlinks, and Google-specific optimizations. GEO Auditor is designed for the **AI search era** — it not only checks technical SEO fundamentals but also directly asks LLMs: "Can you find this site? Are you citing it correctly?" This is a capability no traditional SEO tool provides, and it's becoming essential as AI Overviews, ChatGPT Search, and Perplexity reshape search traffic.

#### Pricing

**$0.03 per run** ($30 per 1,000 runs).

- All technical audit costs included
- LLM probing costs only your OpenRouter tokens (~$0.001/probe)
- **$5 = 166 runs** — cheaper than a single SEO consultant's coffee

#### Links

- [👉 Run on Apify Store — $0.03/run](https://apify.com/yizheng/geo-auditor)
- [📖 Product page & documentation](https://blog.fork.work/tools/geo-auditor)
- [🐙 GitHub repository](https://github.com/nousresearch/geo-auditor)

# Actor input Schema

## `url` (type: `string`):

The public web page URL to audit. Must be a valid HTTP or HTTPS URL.
## `brandName` (type: `string`):

Optional. The brand or company name for context in LLM probe prompts.
## `providers` (type: `array`):

AI models to check for citation accuracy. Requires OPENROUTER_API_KEY secret.
## `probeEnabled` (type: `boolean`):

When enabled, queries each selected AI model for citation accuracy. When disabled, only runs the technical audit.
## `outputFormats` (type: `array`):

Report formats to include in the output dataset.

## Actor input object example

```json
{
  "url": "https://example.com",
  "providers": [
    "chatgpt",
    "claude",
    "gemini"
  ],
  "probeEnabled": true,
  "outputFormats": [
    "json",
    "markdown",
    "html"
  ]
}
````

# 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 = {
    "url": "https://example.com",
    "providers": [
        "chatgpt",
        "claude",
        "gemini"
    ],
    "outputFormats": [
        "json",
        "markdown",
        "html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yizheng/geo-auditor").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 = {
    "url": "https://example.com",
    "providers": [
        "chatgpt",
        "claude",
        "gemini",
    ],
    "outputFormats": [
        "json",
        "markdown",
        "html",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("yizheng/geo-auditor").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 '{
  "url": "https://example.com",
  "providers": [
    "chatgpt",
    "claude",
    "gemini"
  ],
  "outputFormats": [
    "json",
    "markdown",
    "html"
  ]
}' |
apify call yizheng/geo-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GEO Auditor — Technical Site Audit + Live LLM Citation Check",
        "description": "Technical site audit + live LLM citation check: ChatGPT, Claude, Gemini. 6-axis SEO audit with scoring & radar charts. $0.03/run.",
        "version": "0.1",
        "x-build-id": "nOVtMjh1v1t4k3kUP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yizheng~geo-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yizheng-geo-auditor",
                "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/yizheng~geo-auditor/runs": {
            "post": {
                "operationId": "runs-sync-yizheng-geo-auditor",
                "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/yizheng~geo-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-yizheng-geo-auditor",
                "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": [
                    "url"
                ],
                "properties": {
                    "url": {
                        "title": "Page URL",
                        "type": "string",
                        "description": "The public web page URL to audit. Must be a valid HTTP or HTTPS URL."
                    },
                    "brandName": {
                        "title": "Brand / Company name",
                        "type": "string",
                        "description": "Optional. The brand or company name for context in LLM probe prompts."
                    },
                    "providers": {
                        "title": "LLM providers to probe",
                        "type": "array",
                        "description": "AI models to check for citation accuracy. Requires OPENROUTER_API_KEY secret.",
                        "default": [
                            "chatgpt",
                            "claude",
                            "gemini"
                        ]
                    },
                    "probeEnabled": {
                        "title": "Enable LLM probing",
                        "type": "boolean",
                        "description": "When enabled, queries each selected AI model for citation accuracy. When disabled, only runs the technical audit.",
                        "default": true
                    },
                    "outputFormats": {
                        "title": "Output formats",
                        "type": "array",
                        "description": "Report formats to include in the output dataset.",
                        "default": [
                            "json",
                            "markdown",
                            "html"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```