# Website Crawl Preflight Auditor (`sebastian-actors/website-crawl-preflight-auditor`) Actor

Check robots.txt, sitemaps, static extraction quality, crawl risk, and estimated Apify costs before running a crawler or RAG ingestion job.

- **URL**: https://apify.com/sebastian-actors/website-crawl-preflight-auditor.md
- **Developed by:** [Sebastián S](https://apify.com/sebastian-actors) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 domain auditeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Website Crawl Preflight Auditor

Audit robots.txt, sitemaps, static HTML, JavaScript risk, crawl limits, and estimated Apify costs before starting a scraper, SEO audit, or RAG job.

Website Crawl Preflight Auditor performs a bounded, static HTTP-only inspection of up to 10 public website origins. It produces one crawl-readiness audit per origin, explicit outcomes for direct sample URLs, scoped cost scenarios, and practical settings for a downstream crawler.

### What It Checks

- robots.txt access state, user-agent rules, crawl delay, sitemap declarations, and representative disallow paths
- sitemap discovery, index depth, URL counts, metadata coverage, malformed entries, gzip bounds, and parse or fetch errors
- HTTP status, redirects, content type, decoded response size, title, description, canonical, H1s, and robots meta
- static text volume, scripts, JSON-LD, and app-shell markers such as `__NEXT_DATA__`, `__NUXT__`, `ng-version`, `id="root"`, and `id="app"`
- likely JavaScript dependence, noindex pages, canonical mismatches, non-HTML URLs, redirects, and low-content pages
- full-site and recommended-scope static-fetch cost ranges
- recommended page limits, concurrency, request delay, timeouts, allowlists, blocklists, and rendering mode

### Input

Provide at least one of `startUrl`, `sitemapUrl`, or `urls`. Inputs may span multiple origins; each origin is audited independently and processed sequentially.

```json
{
  "startUrl": "https://docs.apify.com",
  "urls": [
    "https://blog.apify.com/",
    "https://www.example.com/about"
  ],
  "maxOrigins": 10,
  "samplePages": 25,
  "maxSitemapUrls": 100000,
  "maxSitemapDepth": 2,
  "sameDomainOnly": true,
  "respectRobotsTxt": true,
  "checkSitemaps": true,
  "checkSamplePages": true,
  "estimateApifyCosts": true,
  "includeRecommendedSettings": true,
  "includeSampleRows": true
}
````

Limits apply independently per origin:

- up to 10 explicit origins per run
- up to 500 direct URLs per input
- up to 250 sampled pages per origin
- up to 500,000 retained sitemap URLs per origin
- sitemap recursion depth up to 3
- sample concurrency up to 10 within one origin

`sameDomainOnly` keeps sitemap records and redirects on the exact audit origin, including scheme and port. It does not prevent you from supplying several explicit origins.

Use regex filters to narrow the recommended crawl scope:

```json
{
  "sitemapUrl": "https://example.com/sitemap.xml",
  "urlAllowlistPatterns": ["/docs/", "/products/"],
  "urlBlocklistPatterns": ["/search", "/tag/", "\\?sort="],
  "samplePages": 50
}
```

### Outputs

The default dataset contains one `crawl_preflight_audit` row per origin. A fully assembled robots-blocked or network-failed report is a completed audit because it still contains the promised evidence. Unsafe input, an internal processing failure, or a charge-limited origin produces an uncharged error row.

The separate `samples` dataset contains URL-level rows with `status: ok | skipped | error`. Every explicit URL receives an outcome, including:

- `SAMPLE_LIMIT_REACHED`
- `SAMPLE_CHECK_DISABLED`
- `URL_NOT_ALLOWLISTED`
- `URL_BLOCKLISTED`
- `OUTSIDE_AUDIT_ORIGIN`
- robots, safety, timeout, response-size, redirect, HTTP, and network failures

Only sitemap URLs selected for sampling receive URL-level rows. Other sitemap URLs remain aggregate counts so output stays bounded.

Output shortcuts:

- `audits`: the default audit dataset view
- `samples`: the separate URL-outcomes dataset view
- `runSummary`: the aggregate `OUTPUT` record

`OUTPUT` reports origin totals, completed and error counts, sample totals, billing state, charged-domain count, warnings, cost guardrails, and the complete audit summaries.

### Robots Behavior

robots.txt is reported as one of:

- `found`: usable rules were fetched and evaluated for the configured user agent
- `unavailable`: a `4xx` response; crawling is allowed
- `unreachable`: a network failure or `5xx`; crawling is disallowed
- `invalid`: unusable or oversized content; crawling is disallowed

This follows RFC 9309 availability behavior. Rules, crawl delay, and disallow-path samples are scoped to the configured user agent. Robots decisions are cached per origin, and redirects are checked against the destination origin's rules before being followed.

### Network Safety

The Actor only accesses public `http` and `https` targets. It rejects URL credentials and loopback, private, link-local, reserved, IPv4-mapped IPv6, or mixed public/private DNS results. URL and DNS safety are enforced on connections and redirects.

Decoded responses are bounded:

- robots.txt: 512 KiB
- HTML samples: 5 MiB
- sitemap XML, including decompressed `.xml.gz`: 50 MiB

Declared oversized responses are rejected before reading the body, streamed responses are aborted when they cross the limit, and the timeout remains active through body consumption. `DOCTYPE` and entity declarations are rejected in sitemap XML.

### Cost Estimates

Cost output separates:

- `fullSite`: estimated static-fetch cost using total sitemap discovery
- `recommendedScope`: estimated cost after retained URL limits, filtering, and the recommended `maxPages`

The default model assumes `$0.20` per compute unit as a Free/Starter baseline and `0.001` to `0.003` compute units per static-fetched page. You can override the model in `costModel`. Estimates exclude browser rendering and proxies, and actual prices vary by plan tier, retries, response sizes, storage, and platform pricing.

When robots.txt declares a crawl delay, the recommendation sets `maxConcurrency` to `1` and exposes the delay as `requestDelaySecs`.

### Crawlability Score

The score is a triage signal, not a guarantee:

- 90-100: excellent static crawl candidate
- 75-89: good candidate with minor warnings
- 55-74: crawlable with constraints
- 30-54: risky or needs manual review/browser rendering
- 0-29: blocked or not recommended

Flags and their evidence are more important than the score. Stable flags include `ROBOTS_TXT_UNREACHABLE`, `ROBOTS_TXT_INVALID`, `ROBOTS_DISALLOWS_TARGET`, `SITEMAP_FETCH_FAILED`, `SITEMAP_INDEX_TOO_DEEP`, `LARGE_SITEMAP`, `SAMPLE_LOW_SUCCESS_RATE`, `JAVASCRIPT_HEAVY_LIKELY`, `LOW_STATIC_TEXT_CONTENT`, `MANY_NOINDEX_PAGES`, `CANONICAL_MISMATCHES`, `REDIRECT_HEAVY`, and `COST_ESTIMATE_HIGH`.

### Billing

Pay-per-event runs charge once for each completed origin audit using the `domain-audited` event. The Actor checks remaining event capacity before starting an origin. When capacity is exhausted, remaining origins receive minimal `CHARGE_LIMIT_REACHED` rows and no further requests are made.

Invalid or private inputs, internal failures, and budget-limited origins are not charged. An origin blocked by robots or affected by fetch failures is charged only when the Actor has completed and assembled its evidence report.

### Recommended Workflow

1. Run Website Crawl Preflight Auditor with representative input.
2. Review robots access, discovered versus retained sitemap counts, sample outcomes, flags, and both cost scenarios.
3. Apply the recommended scope, delay, concurrency, timeout, allowlist, and blocklist settings to the downstream Actor.
4. Use browser rendering only when static HTML evidence shows it is needed.

### V1 Limitations

V1 intentionally excludes browser rendering, proxies, recursive link crawling, authentication, screenshots, and LLM calls. It does not bypass anti-bot systems, crawl login-gated content, perform a full SEO audit, or guarantee exact costs.

Only use this Actor on public websites you are allowed to analyze. You remain responsible for applicable laws, website terms, and crawl policies.

# Actor input Schema

## `startUrl` (type: `string`):

Website URL to audit, such as https://example.com. Used to discover robots.txt and common sitemap locations.

## `sitemapUrl` (type: `string`):

Optional XML sitemap or sitemap index URL to inspect.

## `urls` (type: `array`):

Optional list of public URLs to sample directly.

## `maxOrigins` (type: `integer`):

Maximum number of distinct website origins audited in one run. Limits apply independently to each origin.

## `samplePages` (type: `integer`):

Maximum number of pages to sample for static extraction diagnostics.

## `maxSitemapUrls` (type: `integer`):

Maximum number of sitemap URLs to inspect/count before stopping.

## `maxSitemapDepth` (type: `integer`):

Maximum depth for sitemap index recursion.

## `sameDomainOnly` (type: `boolean`):

Only include sitemap records and redirects on the exact audited origin (scheme, hostname, and port). Explicit input origins are still audited separately.

## `respectRobotsTxt` (type: `boolean`):

Use robots.txt rules when evaluating sample URLs and recommendations.

## `checkSitemaps` (type: `boolean`):

Discover and parse sitemaps when possible.

## `checkSamplePages` (type: `boolean`):

Fetch sample pages to estimate static crawl quality and extraction difficulty.

## `estimateApifyCosts` (type: `boolean`):

Estimate approximate static-fetch compute cost range based on discovered pages and sample diagnostics.

## `includeRecommendedSettings` (type: `boolean`):

Output recommended settings for downstream crawl, SEO audit, or RAG Actors.

## `includeDisallowedPaths` (type: `boolean`):

Include summarized robots.txt disallow path patterns in the output.

## `includeSampleRows` (type: `boolean`):

Also write one dataset row per sampled page.

## `userAgent` (type: `string`):

User agent used for robots.txt checks and HTTP requests.

## `urlAllowlistPatterns` (type: `array`):

Optional regex patterns. If provided, only matching URLs are included in sampling and recommendations.

## `urlBlocklistPatterns` (type: `array`):

Optional regex patterns. Matching URLs are excluded from sampling and recommendations.

## `requestTimeoutSecs` (type: `integer`):

Timeout for robots, sitemap, and sample page requests.

## `maxConcurrency` (type: `integer`):

Maximum number of sample page requests in parallel.

## `costModel` (type: `object`):

Optional static-fetch cost model overrides.

## Actor input object example

```json
{
  "startUrl": "https://docs.apify.com",
  "sitemapUrl": "https://docs.apify.com/sitemap.xml",
  "urls": [],
  "maxOrigins": 10,
  "samplePages": 25,
  "maxSitemapUrls": 100000,
  "maxSitemapDepth": 2,
  "sameDomainOnly": true,
  "respectRobotsTxt": true,
  "checkSitemaps": true,
  "checkSamplePages": true,
  "estimateApifyCosts": true,
  "includeRecommendedSettings": true,
  "includeDisallowedPaths": true,
  "includeSampleRows": true,
  "userAgent": "WebsiteCrawlPreflightBot/1.0 (+https://apify.com)",
  "urlAllowlistPatterns": [],
  "urlBlocklistPatterns": [],
  "requestTimeoutSecs": 20,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `audits` (type: `string`):

One crawl-readiness audit per origin.

## `samples` (type: `string`):

Sampled, skipped, and failed URL outcomes.

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

Aggregate multi-origin report stored under OUTPUT.

# 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 = {
    "startUrl": "https://docs.apify.com",
    "sitemapUrl": "https://docs.apify.com/sitemap.xml"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sebastian-actors/website-crawl-preflight-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 = {
    "startUrl": "https://docs.apify.com",
    "sitemapUrl": "https://docs.apify.com/sitemap.xml",
}

# Run the Actor and wait for it to finish
run = client.actor("sebastian-actors/website-crawl-preflight-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 '{
  "startUrl": "https://docs.apify.com",
  "sitemapUrl": "https://docs.apify.com/sitemap.xml"
}' |
apify call sebastian-actors/website-crawl-preflight-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Crawl Preflight Auditor",
        "description": "Check robots.txt, sitemaps, static extraction quality, crawl risk, and estimated Apify costs before running a crawler or RAG ingestion job.",
        "version": "0.1",
        "x-build-id": "nDtUfkJW20YTjFBde"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sebastian-actors~website-crawl-preflight-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sebastian-actors-website-crawl-preflight-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/sebastian-actors~website-crawl-preflight-auditor/runs": {
            "post": {
                "operationId": "runs-sync-sebastian-actors-website-crawl-preflight-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/sebastian-actors~website-crawl-preflight-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-sebastian-actors-website-crawl-preflight-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",
                "properties": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Website URL to audit, such as https://example.com. Used to discover robots.txt and common sitemap locations."
                    },
                    "sitemapUrl": {
                        "title": "Sitemap URL",
                        "type": "string",
                        "description": "Optional XML sitemap or sitemap index URL to inspect."
                    },
                    "urls": {
                        "title": "Sample URLs",
                        "maxItems": 500,
                        "type": "array",
                        "description": "Optional list of public URLs to sample directly.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxOrigins": {
                        "title": "Maximum origins",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of distinct website origins audited in one run. Limits apply independently to each origin.",
                        "default": 10
                    },
                    "samplePages": {
                        "title": "Sample pages",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of pages to sample for static extraction diagnostics.",
                        "default": 25
                    },
                    "maxSitemapUrls": {
                        "title": "Max sitemap URLs",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum number of sitemap URLs to inspect/count before stopping.",
                        "default": 100000
                    },
                    "maxSitemapDepth": {
                        "title": "Max sitemap depth",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Maximum depth for sitemap index recursion.",
                        "default": 2
                    },
                    "sameDomainOnly": {
                        "title": "Same domain only",
                        "type": "boolean",
                        "description": "Only include sitemap records and redirects on the exact audited origin (scheme, hostname, and port). Explicit input origins are still audited separately.",
                        "default": true
                    },
                    "respectRobotsTxt": {
                        "title": "Respect robots.txt",
                        "type": "boolean",
                        "description": "Use robots.txt rules when evaluating sample URLs and recommendations.",
                        "default": true
                    },
                    "checkSitemaps": {
                        "title": "Check sitemaps",
                        "type": "boolean",
                        "description": "Discover and parse sitemaps when possible.",
                        "default": true
                    },
                    "checkSamplePages": {
                        "title": "Check sample pages",
                        "type": "boolean",
                        "description": "Fetch sample pages to estimate static crawl quality and extraction difficulty.",
                        "default": true
                    },
                    "estimateApifyCosts": {
                        "title": "Estimate Apify costs",
                        "type": "boolean",
                        "description": "Estimate approximate static-fetch compute cost range based on discovered pages and sample diagnostics.",
                        "default": true
                    },
                    "includeRecommendedSettings": {
                        "title": "Include recommended settings",
                        "type": "boolean",
                        "description": "Output recommended settings for downstream crawl, SEO audit, or RAG Actors.",
                        "default": true
                    },
                    "includeDisallowedPaths": {
                        "title": "Include disallowed paths",
                        "type": "boolean",
                        "description": "Include summarized robots.txt disallow path patterns in the output.",
                        "default": true
                    },
                    "includeSampleRows": {
                        "title": "Include sample rows",
                        "type": "boolean",
                        "description": "Also write one dataset row per sampled page.",
                        "default": true
                    },
                    "userAgent": {
                        "title": "User agent",
                        "type": "string",
                        "description": "User agent used for robots.txt checks and HTTP requests.",
                        "default": "WebsiteCrawlPreflightBot/1.0 (+https://apify.com)"
                    },
                    "urlAllowlistPatterns": {
                        "title": "URL allowlist patterns",
                        "type": "array",
                        "description": "Optional regex patterns. If provided, only matching URLs are included in sampling and recommendations.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "urlBlocklistPatterns": {
                        "title": "URL blocklist patterns",
                        "type": "array",
                        "description": "Optional regex patterns. Matching URLs are excluded from sampling and recommendations.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout for robots, sitemap, and sample page requests.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of sample page requests in parallel.",
                        "default": 5
                    },
                    "costModel": {
                        "title": "Cost model",
                        "type": "object",
                        "description": "Optional static-fetch cost model overrides."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
