# Small Business Website Readiness Audit (`ori8_automations/small-business-website-readiness-audit`) Actor

Audit any small-business website in seconds — no browser, no API keys, no bloat. Get a structured dataset and owner-readable Markdown report covering contact signals, broken links, service page presence, metadata quality, and HTTPS basics.

- **URL**: https://apify.com/ori8\_automations/small-business-website-readiness-audit.md
- **Developed by:** [Ori8 Automations](https://apify.com/ori8_automations) (community)
- **Categories:** AI, SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## Small Business Website Readiness Audit

Audit any small-business website in seconds — no browser, no API keys, no bloat. Pages are fetched concurrently, seeded from the site's sitemap, and checked for contact signals, broken links, service-page presence, metadata quality, mobile/viewport and accessibility basics, social-share and schema.org markup, security headers, robots/sitemap basics, and HTTPS. You get a structured dataset plus an owner-readable Markdown report.

This actor is built for agencies, MSPs, freelancers, and automation pipelines that need a fast public-site health check before deeper work. Instead of eyeballing every page by hand, run the same bounded check every time and get repeatable JSON plus a plain-English report you can hand to a client or feed into another workflow.

### Why run it?

Use it when you need:

- a repeatable first-pass website readiness check;
- structured output for intake, QA, or automation pipelines;
- a simple report a non-technical owner can understand;
- quick signals before a redesign, SEO cleanup, or agency handoff;
- a lightweight alternative to full browser/Lighthouse platforms.

### What it checks

For same-host public HTML pages within the page cap, the actor checks:

- page status and fetch success/failure (with a retry on transient errors);
- title, title length, meta description, H1s, canonical URL, and robots meta;
- **duplicate titles and meta descriptions** across the crawled pages;
- **mobile/viewport meta tag** and **`<html lang>`** presence;
- **images missing `alt` text**;
- **Open Graph / Twitter card** social-share tags;
- **JSON-LD structured data** and a `LocalBusiness` schema.org signal;
- **favicon** presence;
- HTTPS usage per page (flags plain-HTTP pages) and recommended **security headers** (HSTS, X-Content-Type-Options, CSP);
- robots.txt and sitemap presence when enabled;
- obvious broken internal links when enabled (HEAD-first, results cached);
- contact/service/location readiness signals (word-boundary matched, no geo hardcoding);
- form presence counts;
- likely JavaScript/client-rendered pages that may need browser-mode review later.

Pages are discovered from both in-page links **and the site's `sitemap.xml`/`sitemap_index.xml`**, so pages that aren't linked from the homepage are still found. When enabled, the crawler **respects `robots.txt` Disallow rules** for its user agent, and every request (including redirects) is checked so it cannot be bounced onto a private/internal host.

### Output

Outputs include:

- default dataset rows for each analyzed page;
- a summary row in the dataset;
- `SUMMARY` in key-value storage;
- `REPORT.md` in key-value storage when Markdown reporting is enabled.

Page rows include fields such as `url`, `status_code`, `redirect_count`, `page_bytes`, `title`, `meta_description`, `h1_texts`, `html_lang`, `viewport_meta_present`, `favicon_present`, `open_graph_present`, `twitter_card_present`, `structured_data_present`, `local_business_schema_present`, `images_count`, `images_missing_alt_count`, `security_headers`, `broken_internal_links_count`, `forms_count`, `contact_signal`, `service_page_signal`, `location_signal`, `duplicate_title`, `duplicate_meta_description`, `needs_browser_mode`, and `findings`.

The dataset ships with a **"Pages" table view** so the results render as a clean table in the Apify console, not just raw JSON.

Summary output includes pages analyzed, readiness score, robots/sitemap/HTTPS signals, top findings, and a static-crawl limitation note.

### Example report excerpt

```markdown
## Website Readiness Audit: exampleplumbing.test

Generated: 2026-07-05T18:00:00Z
Pages analyzed: 5/10
Audit type: Static public-page readiness audit

### Executive summary

- Overall readiness: 74/100 — Needs a few fixes
- Broken internal links found within cap: 2
- Pages that may need browser mode: 0

### Highest-priority fixes

| Priority | Area | Count | Finding |
|---|---|---:|---|
| high | `BROKEN_INTERNAL_LINKS` | 2 | Two internal links appear broken within the crawl cap. |
| medium | `MISSING_META_DESCRIPTION` | 3 | Meta description is missing. |

### Contact and conversion readiness

- Contact page/signals detected: yes
- Forms detected: yes
- Obvious service signals: yes

### What this audit does not cover

This is not a full SEO audit, ranking forecast, legal/accessibility certification, performance/Lighthouse report, or security/vulnerability scan.
````

### Input

Required:

- `startUrl` — public homepage or starting URL for a website you own or are authorized to audit.
- `acknowledgeAuthorizedUse` — must be `true`.

Useful optional settings:

- `maxPages` — default 10, maximum 50.
- `crawlConcurrency` — pages fetched in parallel; default 5, maximum 10.
- `useSitemapForDiscovery` — seed the crawl from sitemap.xml; default true.
- `respectRobotsDisallow` — obey robots.txt Disallow rules; default true.
- `includeRobotsAndSitemapChecks` — default true.
- `includeBrokenInternalLinkCheck` — default true.
- `retryFailedRequests` — retry once on transient errors; default true.
- `includeMarkdownReport` — default true.
- `requestTimeoutSeconds` — default 15 seconds.

Example input:

```json
{
  "startUrl": "https://example.com",
  "maxPages": 10,
  "crawlConcurrency": 5,
  "useSitemapForDiscovery": true,
  "respectRobotsDisallow": true,
  "includeRobotsAndSitemapChecks": true,
  "includeBrokenInternalLinkCheck": true,
  "includeMarkdownReport": true,
  "acknowledgeAuthorizedUse": true,
  "requestTimeoutSeconds": 15
}
```

### What this does **not** do

This v1 does **not** perform:

- browser rendering, Playwright, Lighthouse, screenshots, Core Web Vitals, or proxy mode;
- full SEO, accessibility, security, privacy, legal, or performance audits;
- credentialed/private-page access;
- form submission;
- contact/email/phone harvesting;
- Google Search, Maps, reviews, SERP, or directory scraping;
- outreach, enrichment, lead generation, or vulnerability scanning;
- paid API, LLM, or third-party enrichment calls.

### Limitations

Best results are on standard HTML sites. JavaScript-heavy sites, React/SPAs, and pages that render most content client-side may return incomplete or sparse results in v1. The actor exposes `needs_browser_mode` and `content_may_be_incomplete` instead of pretending a static crawl saw everything.

The crawl is same-host only and capped at 50 pages to keep runtime and cost predictable.

### Local development

```bash
python3 -m unittest discover -s tests -v
python3 -m py_compile src/website_audit.py src/main.py src/__main__.py tests/test_website_audit.py
APIFY_CLI_DISABLE_TELEMETRY=1 npx --yes apify-cli validate-schema
```

# Actor input Schema

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

Public homepage or starting URL for a website you own or are authorized to audit. Use only non-confidential public websites; do not enter private, credentialed, or internal URLs.

## `maxPages` (type: `integer`):

Maximum same-host HTML pages to fetch and analyze. Default 10; maximum 50 to keep runtime and cost predictable.

## `crawlConcurrency` (type: `integer`):

How many pages to fetch in parallel. Higher is faster but hits the target site harder. Default 5; maximum 10.

## `useSitemapForDiscovery` (type: `boolean`):

Seed the crawl from sitemap.xml / sitemap\_index.xml so pages that aren't linked from the homepage are still found.

## `respectRobotsDisallow` (type: `boolean`):

Skip URLs disallowed for this user agent by the site's robots.txt. Polite crawling; recommended on.

## `includeRobotsAndSitemapChecks` (type: `boolean`):

Fetch robots.txt and sitemap hints for the same host when available.

## `includeBrokenInternalLinkCheck` (type: `boolean`):

Check discovered same-domain links within the crawl/page cap for obvious broken internal links.

## `retryFailedRequests` (type: `boolean`):

Retry a page once with a short backoff on a transient network error before marking it failed.

## `requestTimeoutSeconds` (type: `integer`):

Per-request timeout in seconds. Keep modest for automated tests and predictable cost.

## `userAgentLabel` (type: `string`):

Optional descriptive user agent label for polite public-page fetching. Do not use this actor to bypass source controls, rate limits, or access restrictions.

## `includeMarkdownReport` (type: `boolean`):

Create an owner-readable Markdown report in key-value storage in addition to structured dataset rows.

## `acknowledgeAuthorizedUse` (type: `boolean`):

Required. Use this actor only with public, user-owned, or user-authorized non-confidential websites. No credentialed/private sources, contact harvesting, form submission, Google/Maps/review scraping, or vulnerability scanning.

## Actor input object example

```json
{
  "startUrl": "https://example.com",
  "maxPages": 10,
  "crawlConcurrency": 5,
  "useSitemapForDiscovery": true,
  "respectRobotsDisallow": true,
  "includeRobotsAndSitemapChecks": true,
  "includeBrokenInternalLinkCheck": true,
  "retryFailedRequests": true,
  "requestTimeoutSeconds": 15,
  "userAgentLabel": "Ori8WebsiteReadinessAudit/1.0",
  "includeMarkdownReport": true,
  "acknowledgeAuthorizedUse": true
}
```

# 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://example.com",
    "maxPages": 10,
    "crawlConcurrency": 5,
    "useSitemapForDiscovery": true,
    "respectRobotsDisallow": true,
    "includeRobotsAndSitemapChecks": true,
    "includeBrokenInternalLinkCheck": true,
    "retryFailedRequests": true,
    "requestTimeoutSeconds": 15,
    "userAgentLabel": "Ori8WebsiteReadinessAudit/1.0",
    "includeMarkdownReport": true,
    "acknowledgeAuthorizedUse": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("ori8_automations/small-business-website-readiness-audit").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://example.com",
    "maxPages": 10,
    "crawlConcurrency": 5,
    "useSitemapForDiscovery": True,
    "respectRobotsDisallow": True,
    "includeRobotsAndSitemapChecks": True,
    "includeBrokenInternalLinkCheck": True,
    "retryFailedRequests": True,
    "requestTimeoutSeconds": 15,
    "userAgentLabel": "Ori8WebsiteReadinessAudit/1.0",
    "includeMarkdownReport": True,
    "acknowledgeAuthorizedUse": True,
}

# Run the Actor and wait for it to finish
run = client.actor("ori8_automations/small-business-website-readiness-audit").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://example.com",
  "maxPages": 10,
  "crawlConcurrency": 5,
  "useSitemapForDiscovery": true,
  "respectRobotsDisallow": true,
  "includeRobotsAndSitemapChecks": true,
  "includeBrokenInternalLinkCheck": true,
  "retryFailedRequests": true,
  "requestTimeoutSeconds": 15,
  "userAgentLabel": "Ori8WebsiteReadinessAudit/1.0",
  "includeMarkdownReport": true,
  "acknowledgeAuthorizedUse": true
}' |
apify call ori8_automations/small-business-website-readiness-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ori8_automations/small-business-website-readiness-audit",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Small Business Website Readiness Audit",
        "description": "Audit any small-business website in seconds — no browser, no API keys, no bloat. Get a structured dataset and owner-readable Markdown report covering contact signals, broken links, service page presence, metadata quality, and HTTPS basics.",
        "version": "1.0",
        "x-build-id": "rXZ1YWAsA0LVSVgU7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ori8_automations~small-business-website-readiness-audit/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ori8_automations-small-business-website-readiness-audit",
                "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/ori8_automations~small-business-website-readiness-audit/runs": {
            "post": {
                "operationId": "runs-sync-ori8_automations-small-business-website-readiness-audit",
                "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/ori8_automations~small-business-website-readiness-audit/run-sync": {
            "post": {
                "operationId": "run-sync-ori8_automations-small-business-website-readiness-audit",
                "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": [
                    "startUrl",
                    "acknowledgeAuthorizedUse"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Website URL",
                        "type": "string",
                        "description": "Public homepage or starting URL for a website you own or are authorized to audit. Use only non-confidential public websites; do not enter private, credentialed, or internal URLs."
                    },
                    "maxPages": {
                        "title": "Maximum pages to analyze",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum same-host HTML pages to fetch and analyze. Default 10; maximum 50 to keep runtime and cost predictable.",
                        "default": 10
                    },
                    "crawlConcurrency": {
                        "title": "Concurrent requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many pages to fetch in parallel. Higher is faster but hits the target site harder. Default 5; maximum 10.",
                        "default": 5
                    },
                    "useSitemapForDiscovery": {
                        "title": "Discover pages from sitemap.xml",
                        "type": "boolean",
                        "description": "Seed the crawl from sitemap.xml / sitemap_index.xml so pages that aren't linked from the homepage are still found.",
                        "default": true
                    },
                    "respectRobotsDisallow": {
                        "title": "Respect robots.txt Disallow rules",
                        "type": "boolean",
                        "description": "Skip URLs disallowed for this user agent by the site's robots.txt. Polite crawling; recommended on.",
                        "default": true
                    },
                    "includeRobotsAndSitemapChecks": {
                        "title": "Check robots.txt and sitemap",
                        "type": "boolean",
                        "description": "Fetch robots.txt and sitemap hints for the same host when available.",
                        "default": true
                    },
                    "includeBrokenInternalLinkCheck": {
                        "title": "Check broken internal links",
                        "type": "boolean",
                        "description": "Check discovered same-domain links within the crawl/page cap for obvious broken internal links.",
                        "default": true
                    },
                    "retryFailedRequests": {
                        "title": "Retry failed requests",
                        "type": "boolean",
                        "description": "Retry a page once with a short backoff on a transient network error before marking it failed.",
                        "default": true
                    },
                    "requestTimeoutSeconds": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Per-request timeout in seconds. Keep modest for automated tests and predictable cost.",
                        "default": 15
                    },
                    "userAgentLabel": {
                        "title": "User agent label",
                        "type": "string",
                        "description": "Optional descriptive user agent label for polite public-page fetching. Do not use this actor to bypass source controls, rate limits, or access restrictions.",
                        "default": "Ori8WebsiteReadinessAudit/1.0"
                    },
                    "includeMarkdownReport": {
                        "title": "Create Markdown report",
                        "type": "boolean",
                        "description": "Create an owner-readable Markdown report in key-value storage in addition to structured dataset rows.",
                        "default": true
                    },
                    "acknowledgeAuthorizedUse": {
                        "title": "I am authorized to audit this public website",
                        "type": "boolean",
                        "description": "Required. Use this actor only with public, user-owned, or user-authorized non-confidential websites. No credentialed/private sources, contact harvesting, form submission, Google/Maps/review scraping, or vulnerability scanning.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
