# Sitemap Analyzer — Recursive Parse, Health Check, AI Tags (`elder_contrabasson/sitemap-analyzer`) Actor

Parse any sitemap.xml recursively, extract all URLs with metadata, check HTTP health status, and optionally cluster URLs by topic using Claude AI. Perfect for SEO audits and site migration.

- **URL**: https://apify.com/elder\_contrabasson/sitemap-analyzer.md
- **Developed by:** [Andrei](https://apify.com/elder_contrabasson) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Sitemap Analyzer

Parse any sitemap recursively, extract every URL with metadata, check HTTP health, and optionally cluster URLs by topic with AI. Built for SEO audits, site migrations, and competitor analysis.

### What this actor does

Most sitemap extractors just give you a flat list of URLs. This actor goes further:

- **Smart resolution** — accepts a bare domain, a subfolder URL, or a direct sitemap URL, and finds the right sitemap for each
- **Recursive parsing** — handles nested sitemap-index files (parent to child) automatically
- **Gzip support** — transparently decompresses `.xml.gz` sitemaps at any nesting level
- **URL analysis** — depth, path segments, and source sitemap for every URL
- **HTTP health checks** — verify each URL returns 200 and measure response time (optional)
- **AI clustering** — group URLs into topic clusters with Claude (optional, bring your own key)
- **Tree mode** — map a site's sitemap structure instead of extracting URLs
- **Anti-bot resilience** — browser-grade fingerprinting, request throttling, and automatic retry on soft-bans

### Quick start

Provide a URL and run:

    {
      "siteUrl": "https://example.com"
    }

The actor checks `robots.txt`, tries common sitemap paths, parses everything it finds recursively, and returns every URL with metadata.

You can also point it straight at a sitemap:

    {
      "sitemapUrl": "https://example.com/sitemap_index.xml"
    }

### How the sitemap is resolved

The actor accepts three kinds of entry and resolves each differently:

1. **Bare domain** (`example.com`) — reads `robots.txt`, then probes common paths (`/sitemap.xml`, `/sitemap_index.xml`, `/sitemap.xml.gz`).
2. **Subfolder URL** (`example.com/blog`) — filters `robots.txt` sitemap directives by the subpath, then probes subfolder-specific paths (`/blog/sitemap.xml`, `/blog/sitemaps/sitemap.xml`, including `.gz`). Falls back to the root sitemap only as a last resort, and flags it with a warning.
3. **Direct sitemap URL** (`sitemapUrl` field, or any `.xml` / `.xml.gz` link) — used as-is, no auto-detection.

The first item in the dataset is always a `manifest` record describing exactly how the sitemap was resolved, including the full resolution trail. This makes it easy to see why a given sitemap was chosen.

### Input fields

- **siteUrl** (required) — Domain, subfolder URL, or direct sitemap URL
- **sitemapUrl** — Explicit sitemap URL; overrides all auto-detection
- **maxUrls** — Limit total URLs returned (0 = unlimited, default 1000)
- **maxSitemaps** — Limit how many child sitemaps are walked (0 = unlimited)
- **maxDepth** — Max sitemap-index nesting depth to follow (default 6)
- **requestDelayMs** — Pause between sitemap fetches (default 300; raise to 800-1500 for strict anti-bot sites)
- **enableHealthCheck** — HEAD-request each URL to check it returns 200 (default false)
- **healthCheckConcurrency** — Parallel health checks (default 10, max 50)
- **enableAiClustering** — Group URLs by topic with Claude (default false)
- **anthropicApiKey** — Your Anthropic API key (BYOK, required if AI clustering enabled)
- **respectRobotsTxt** — Honor robots.txt directives (default true)
- **sitemapTreeMode** — Analyze child sitemaps instead of extracting URLs (default false)
- **sampleUrlsPerSitemap** — In tree mode, sample this many URLs per child sitemap (0-100)
- **useProxy** — Route requests through Apify proxy (default false)
- **proxyType** — `datacenter` (fast, cheap) or `residential` (bypasses more anti-bot systems)

### Output format

Every dataset item has a `type` field. There are four types:

**`manifest`** — always the first item. Describes how the sitemap was resolved:

    {
      "type": "manifest",
      "entryUrl": "https://example.com/blog",
      "rootDomain": "https://example.com",
      "resolvedSitemapUrl": "https://example.com/blog/sitemap.xml",
      "resolutionMethod": "subpath-common-path",
      "resolutionTrail": ["entry: ...", "fetching robots.txt: ...", "..."],
      "sitemapsDiscovered": 1,
      "warning": null,
      "mode": "urls"
    }

**`url`** — one per extracted URL (URL mode):

    {
      "type": "url",
      "url": "https://example.com/blog/post-1",
      "loc": "https://example.com/blog/post-1",
      "lastmod": "2025-12-01",
      "changefreq": "weekly",
      "priority": "0.8",
      "depth": "2",
      "pathSegments": "blog/post-1",
      "fromSitemap": "https://example.com/sitemap.xml",
      "statusCode": "200",
      "responseTimeMs": "234",
      "contentType": "text/html",
      "aiCluster": "blog-post"
    }

`statusCode`, `responseTimeMs`, `contentType` appear only with health check enabled. `aiCluster` appears only with AI clustering enabled.

**`sitemap`** — one per child sitemap (tree mode):

    {
      "type": "sitemap",
      "sitemapUrl": "https://example.com/sitemaps/sitemap0.xml.gz",
      "urlCount": "50000",
      "sitemapDepth": "1",
      "parentSitemap": "https://example.com/sitemap.xml",
      "sampleUrls": "https://... | https://... | https://..."
    }

**`summary`** — always the last item. Totals and why the run stopped:

    {
      "type": "summary",
      "totalUrls": 12500,
      "sitemapsParsed": 8,
      "stoppedReason": "completed"
    }

`stoppedReason` can be `completed`, `maxUrls reached`, `maxSitemaps reached`, or `maxDepth reached`.

### Sitemap tree mode

Instead of extracting individual URLs, tree mode maps the structure of a site's sitemap. For each child sitemap it returns the URL, how many URLs it contains, its depth, its parent, and optionally a few sample URLs.

This is built for competitor scale analysis. A large site may have a sitemap index pointing to 160 child sitemaps; tree mode tells you instantly "160 sitemaps, 8M URLs total" and lets you peek at what each one holds, without downloading millions of URLs.

Enable it with `sitemapTreeMode: true`. Set `sampleUrlsPerSitemap` to 3-10 to also get example URLs from each child sitemap. Results are written to the dataset progressively, one sitemap at a time, so partial output survives even if a run is interrupted.

### Anti-bot handling

The actor uses browser-grade request fingerprinting, which gets past many basic anti-bot defenses that block plain HTTP clients. For stricter sites it also has two more layers:

- **Throttling** — `requestDelayMs` spaces out sitemap requests. Strict sites with anti-bot protection start returning HTML decoy pages instead of XML under request-rate pressure; raising the delay to 800-1500ms greatly reduces this.
- **Soft-ban retry** — when a server returns HTTP 200 but the body is an HTML anti-bot page rather than a sitemap, the actor detects it and retries that request with exponential backoff.
- **Proxy** — set `useProxy: true` and choose `proxyType`. `datacenter` is fast and cheap; `residential` bypasses more systems but is slower and costs more.

Limitation: no approach bypasses full JavaScript-challenge systems (Cloudflare/DataDome interactive challenges). Sites with that level of protection cannot be reached by any non-browser tool.

### Technical notes

- Handles nested sitemap-index files recursively, up to `maxDepth` levels
- Transparently decompresses gzip-compressed sitemaps (`.xml.gz`) at any level
- Respects `maxUrls`, `maxSitemaps`, and `maxDepth` as hard limits
- Health checks run with configurable parallelism
- AI clustering uses Claude Haiku (BYOK)

### Use cases

**SEO audit** — find dead pages (404), slow pages, and pages missing from your sitemap.

**Site migration** — get the complete URL inventory before moving CMS.

**Competitive research** — map a competitor's full site structure and scale with tree mode.

**Sitemap validation** — verify that every URL in your sitemap returns 200.

### Support

Found a bug or have a feature request? Contact the developer through the actor's page on Apify.

# Actor input Schema

## `siteUrl` (type: `string`):

Accepts three kinds of input: (a) a root domain - robots.txt and common paths are tried automatically; (b) a subfolder URL like example.com/blog - the subfolder sitemap is resolved, filtering robots.txt directives by the subpath; (c) a direct sitemap URL (.xml, .xml.gz, or sitemap-index).
## `sitemapUrl` (type: `string`):

If set, this exact sitemap URL is used and all auto-detection is skipped. Most reliable when you already know the sitemap address. Accepts .xml, .xml.gz, and sitemap-index files.
## `maxUrls` (type: `integer`):

Hard cap on URLs extracted (URL mode). Crawl stops when reached. Set to 0 for unlimited.
## `maxSitemaps` (type: `integer`):

Hard cap on the number of child sitemaps walked (both modes). Keeps runs predictable on huge sitemap-indexes. 0 = unlimited.
## `maxDepth` (type: `integer`):

How deep to follow nested sitemap-index files. Depth 0 = the entry sitemap itself.
## `requestDelayMs` (type: `integer`):

Pause between consecutive sitemap fetches. Higher values reduce anti-bot soft-bans on strict sites (800-1500ms recommended for sites with anti-bot protection). 0 = no delay (fastest).
## `enableHealthCheck` (type: `boolean`):

Send HEAD request to each URL to verify it returns 200. Adds ~1 sec per URL.
## `healthCheckConcurrency` (type: `integer`):

How many URLs to check in parallel. Higher = faster but more aggressive on target site.
## `enableAiClustering` (type: `boolean`):

Group URLs into topic clusters using Claude (e.g. product pages, blog posts, support docs). Requires Anthropic API key.
## `anthropicApiKey` (type: `string`):

Your Anthropic API key (sk-ant-...). BYOK - we don't store it. Get one at console.anthropic.com
## `respectRobotsTxt` (type: `boolean`):

Check robots.txt before scraping and skip URLs that are disallowed.
## `sitemapTreeMode` (type: `boolean`):

Instead of extracting URLs, list every child sitemap inside the index: its URL, how many URLs it contains, depth, and parent. Useful for competitor scale analysis.
## `sampleUrlsPerSitemap` (type: `integer`):

In tree mode, also pull this many sample URLs from each child sitemap (0 = none, just counts).
## `useProxy` (type: `boolean`):

Route requests through Apify datacenter proxy + rotate User-Agent. Helps against rate-limiting and IP bans. Does NOT bypass Cloudflare/DataDome JS-challenges.
## `proxyType` (type: `string`):

Datacenter — fast and cheap, good vs rate-limits. Residential — slower and more expensive, but bypasses many anti-bot systems. Residential requires the RESIDENTIAL proxy group to be available in your Apify account.

## Actor input object example

```json
{
  "siteUrl": "https://www.apify.com",
  "maxUrls": 1000,
  "maxSitemaps": 0,
  "maxDepth": 6,
  "requestDelayMs": 300,
  "enableHealthCheck": false,
  "healthCheckConcurrency": 10,
  "enableAiClustering": false,
  "respectRobotsTxt": true,
  "sitemapTreeMode": false,
  "sampleUrlsPerSitemap": 0,
  "useProxy": false,
  "proxyType": "datacenter"
}
````

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("elder_contrabasson/sitemap-analyzer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("elder_contrabasson/sitemap-analyzer").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 '{}' |
apify call elder_contrabasson/sitemap-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sitemap Analyzer — Recursive Parse, Health Check, AI Tags",
        "description": "Parse any sitemap.xml recursively, extract all URLs with metadata, check HTTP health status, and optionally cluster URLs by topic using Claude AI. Perfect for SEO audits and site migration.",
        "version": "0.0",
        "x-build-id": "DmTIISfClLmwH6K4J"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/elder_contrabasson~sitemap-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-elder_contrabasson-sitemap-analyzer",
                "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/elder_contrabasson~sitemap-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-elder_contrabasson-sitemap-analyzer",
                "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/elder_contrabasson~sitemap-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-elder_contrabasson-sitemap-analyzer",
                "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": [
                    "siteUrl"
                ],
                "properties": {
                    "siteUrl": {
                        "title": "Site URL, subfolder URL, or direct sitemap URL",
                        "type": "string",
                        "description": "Accepts three kinds of input: (a) a root domain - robots.txt and common paths are tried automatically; (b) a subfolder URL like example.com/blog - the subfolder sitemap is resolved, filtering robots.txt directives by the subpath; (c) a direct sitemap URL (.xml, .xml.gz, or sitemap-index).",
                        "default": "https://www.apify.com"
                    },
                    "sitemapUrl": {
                        "title": "Explicit sitemap URL (optional, overrides auto-detection)",
                        "type": "string",
                        "description": "If set, this exact sitemap URL is used and all auto-detection is skipped. Most reliable when you already know the sitemap address. Accepts .xml, .xml.gz, and sitemap-index files."
                    },
                    "maxUrls": {
                        "title": "Max URLs to process",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on URLs extracted (URL mode). Crawl stops when reached. Set to 0 for unlimited.",
                        "default": 1000
                    },
                    "maxSitemaps": {
                        "title": "Max child sitemaps to process",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on the number of child sitemaps walked (both modes). Keeps runs predictable on huge sitemap-indexes. 0 = unlimited.",
                        "default": 0
                    },
                    "maxDepth": {
                        "title": "Max sitemap-index nesting depth",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How deep to follow nested sitemap-index files. Depth 0 = the entry sitemap itself.",
                        "default": 6
                    },
                    "requestDelayMs": {
                        "title": "Delay between sitemap requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Pause between consecutive sitemap fetches. Higher values reduce anti-bot soft-bans on strict sites (800-1500ms recommended for sites with anti-bot protection). 0 = no delay (fastest).",
                        "default": 300
                    },
                    "enableHealthCheck": {
                        "title": "Check HTTP status of each URL",
                        "type": "boolean",
                        "description": "Send HEAD request to each URL to verify it returns 200. Adds ~1 sec per URL.",
                        "default": false
                    },
                    "healthCheckConcurrency": {
                        "title": "Concurrent health check requests",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many URLs to check in parallel. Higher = faster but more aggressive on target site.",
                        "default": 10
                    },
                    "enableAiClustering": {
                        "title": "Cluster URLs by topic using AI (optional)",
                        "type": "boolean",
                        "description": "Group URLs into topic clusters using Claude (e.g. product pages, blog posts, support docs). Requires Anthropic API key.",
                        "default": false
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API key (only if AI clustering enabled)",
                        "type": "string",
                        "description": "Your Anthropic API key (sk-ant-...). BYOK - we don't store it. Get one at console.anthropic.com"
                    },
                    "respectRobotsTxt": {
                        "title": "Respect robots.txt",
                        "type": "boolean",
                        "description": "Check robots.txt before scraping and skip URLs that are disallowed.",
                        "default": true
                    },
                    "sitemapTreeMode": {
                        "title": "Sitemap tree mode (analyze child sitemaps instead of URLs)",
                        "type": "boolean",
                        "description": "Instead of extracting URLs, list every child sitemap inside the index: its URL, how many URLs it contains, depth, and parent. Useful for competitor scale analysis.",
                        "default": false
                    },
                    "sampleUrlsPerSitemap": {
                        "title": "Sample URLs per child sitemap (tree mode only)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "In tree mode, also pull this many sample URLs from each child sitemap (0 = none, just counts).",
                        "default": 0
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy (datacenter)",
                        "type": "boolean",
                        "description": "Route requests through Apify datacenter proxy + rotate User-Agent. Helps against rate-limiting and IP bans. Does NOT bypass Cloudflare/DataDome JS-challenges.",
                        "default": false
                    },
                    "proxyType": {
                        "title": "Proxy type (only if proxy enabled)",
                        "enum": [
                            "datacenter",
                            "residential"
                        ],
                        "type": "string",
                        "description": "Datacenter — fast and cheap, good vs rate-limits. Residential — slower and more expensive, but bypasses many anti-bot systems. Residential requires the RESIDENTIAL proxy group to be available in your Apify account.",
                        "default": "datacenter"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```