# Technical On-Page SEO & Meta Auditor (`gp005/seo-onpage-auditor`) Actor

Audit any website's on-page SEO: titles, meta descriptions, H1 tags, canonical URLs, hreflang, Open Graph, Twitter Cards, JSON-LD schema, broken links, image alt text, and robots compliance. Single polite crawl, first-party domains only.

- **URL**: https://apify.com/gp005/seo-onpage-auditor.md
- **Developed by:** [Geo](https://apify.com/gp005) (community)
- **Categories:** Developer tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 page auditeds

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## Technical On-Page SEO & Meta Auditor

[![Built with Apify](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178c6)](https://www.typescriptlang.org/)

A comprehensive on-page SEO audit tool that crawls your website's key pages and analyzes critical ranking signals: page titles, meta descriptions, H1 tags, canonical URLs, hreflang annotations, Open Graph tags, Twitter Cards, JSON-LD structured data, link health, image alt text, and robots.txt compliance.

> **Designed for your own first-party domains.** The auditor reads only public HTML and standards-defined files (/robots.txt, /sitemap.xml). Single-request politeness, identifiable user-agent, full robots.txt compliance built in.

---

### 🚀 Features

- **Title & Meta Analysis** — Checks title length (30–60 chars), meta description length (50–160 chars), and detects missing tags
- **Heading Structure** — Validates H1 count (exactly 1 recommended) and extracts heading content
- **Canonical & Hreflang** — Detects canonical URLs and hreflang annotations for international SEO
- **Social Meta Tags** — Extracts Open Graph (og:title, og:description, og:image) and Twitter Card tags
- **Structured Data** — Identifies JSON-LD schema blocks on each page
- **Link Health Check** — Audits internal and outbound links with HEAD-request status verification
- **Image Alt Text Audit** — Counts images with and without alt text
- **Meta Robots Directives** — Flags noindex/nofollow directives
- **Page Size Analysis** — Detects oversized pages (>500 KB) that may impact Core Web Vitals
- **Robots.txt Compliance** — Reads and respects your site's robots.txt, crawl-delay, and disallowed paths
- **Sitemap Detection** — Checks for the presence of /sitemap.xml
- **SEO Score** — Overall score (0–100) with per-issue penalty breakdown

### 📋 Use Cases

| Use Case | Description |
|----------|-------------|
| **New Site Launch** | Audit pages before going live to catch missing meta tags, broken links, and poor heading structure |
| **SEO Migration** | After a site redesign or CMS migration, verify all pages retain their SEO elements |
| **Content Audit** | Run quarterly audits to maintain SEO hygiene across your content library |
| **Competitive Benchmarking** | Compare your on-page SEO posture against industry standards |
| **Pre-Launch Checklist** | Integrate into your CI/CD pipeline as a quality gate before deploying |

### ⚙️ Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `domain` | string | ✅ Yes | `example.com` | Root domain to audit (without protocol) |
| `paths` | array | No | `["/", "/about", "/contact", "/blog", "/products", "/services"]` | URL paths to crawl |
| `maxPages` | integer | No | `10` | Maximum pages to audit (capped at 50) |
| `timeoutSecs` | integer | No | `15` | Per-request timeout in seconds |

### 📊 Output Schema

Each crawled page produces a dataset item with:

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Audited page URL |
| `score` | integer | Overall SEO score (0–100) |
| `statusCode` | integer | HTTP response status |
| `pageTitle` | string/null | `<title>` tag content |
| `titleLength` | integer/null | Title character count |
| `metaDescription` | string/null | Meta description content |
| `metaDescriptionLength` | integer/null | Meta description character count |
| `h1Count` | integer | Number of `<h1>` tags |
| `h1Tags` | string[] | H1 heading text |
| `canonicalUrl` | string/null | Canonical URL |
| `hreflangTags` | object[] | Hreflang annotations |
| `openGraphTags` | object | Open Graph meta tags |
| `twitterCardTags` | object | Twitter Card meta tags |
| `metaRobots` | string/null | Robots meta directive |
| `jsonLdSchemas` | string[] | Raw JSON-LD blocks |
| `internalLinks` | object[] | Internal links with status |
| `outboundLinks` | object[] | External links with status |
| `imagesMissingAlt` | integer | Images lacking alt text |
| `imagesWithAlt` | integer | Images with alt text |
| `pageSizeBytes` | integer | Raw HTML size |
| `issues` | object[] | List of SEO issues found |

### 🏷️ Issue Types

| Issue Type | Severity | Penalty |
|------------|----------|---------|
| `missing-title` | 🔴 Critical | −15 pts |
| `meta-robots-noindex` | 🔴 Critical | −20 pts |
| `broken-internal-link` | 🔴 Critical | −8 pts |
| `multiple-h1` | 🔴 Critical | −10 pts |
| `missing-meta-description` | 🔴 Critical | −10 pts |
| `short-title` / `long-title` | 🟡 Warning | −3/−5 pts |
| `missing-h1` | 🟡 Warning | −5 pts |
| `missing-canonical` | 🟡 Warning | −5 pts |
| `short/long-meta-description` | 🟡 Warning | −3/−5 pts |
| `missing-og-title` | 🟡 Warning | −5 pts |
| `broken-outbound-link` | 🟡 Warning | −5 pts |
| `images-missing-alt` | 🟡 Warning | −5 pts |
| `large-page` | 🟡 Warning | −3 pts |
| `missing-og-description` | 🔵 Info | −3 pts |
| `missing-og-image` | 🔵 Info | −3 pts |
| `missing-twitter-card` | 🔵 Info | −3 pts |
| `no-jsonld` | 🔵 Info | −2 pts |

### 💰 Pricing & Events

This actor uses **Pay Per Event (PPE)** pricing:

| Event | Price | Description |
|-------|-------|-------------|
| `actor-start` | $0.01 | Synthetic start event (first 5s subsidized) |
| `url-audited` | $0.02 | Per page fully analyzed for SEO signals |
| `issue-flagged` | $0.01 | Per SEO issue found (capped at 10 per domain) |

#### Worked Example: 3-Page Audit

**Input:** `{ "domain": "example.com", "paths": ["/", "/about", "/contact"] }`

**Expected events and cost:**
| Event | Count | Cost |
|-------|-------|------|
| `actor-start` | 1 | $0.01 |
| `url-audited` | 3 | $0.06 |
| `issue-flagged` | ~6 (2 issues/page avg) | $0.06 |
| **Total** | | **~$0.13** |

**Platform Cost Analysis:**
- Estimated CU for a 3-page audit: ~0.002–0.003 CU
- At $0.20/CU: platform cost ≈ $0.0004–$0.0006
- **Margin:** Event revenue ($0.13) is **200×+** platform cost
- Well under the 30% cost/revenue target

### 🔧 Integration Notes

#### API (REST)
```bash
curl -X POST "https://api.apify.com/v2/acts/gp005~seo-onpage-auditor/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "domain": "your-site.com",
    "paths": ["/", "/about", "/contact"]
  }'
````

#### MCP (Apify Model Context Protocol)

Use the Apify MCP integration to run this actor directly from Claude, Cursor, or any MCP-compatible agent. The MCP tool name is `act-gp005-seo-onpage-auditor`.

#### Webhooks

Set up a webhook on run completion to push SEO audit results to:

- Slack (via incoming webhook)
- Google Sheets (via Make/Zapier)
- Custom API endpoint

#### Make (Integromat) / n8n

Use the Apify module in Make or n8n to trigger audits on a schedule (e.g., weekly) and pipe results into your reporting dashboard.

### ⚠️ Honest Limitations

1. **First-party domains only** — This actor assumes you own or have permission to audit the target domain. Do not point it at third-party sites without ownership verification.
2. **No JavaScript rendering** — The auditor parses static HTML only. Single-page applications (React, Vue, Angular) may yield incomplete results if content is rendered client-side.
3. **Link checking is sampled** — Up to 20 links per page are checked for performance. Very large pages may have undetected broken links.
4. **Not a full technical SEO audit** — This covers on-page elements only. It does NOT check: backlinks, keyword rankings, page speed (real Core Web Vitals), sitemap validity, mobile-friendliness, or server configuration.
5. **Single-domain only** — Each run audits one domain. For multi-site audits, run multiple instances.
6. **Public pages only** — Login-gated, paywalled, or behind-authentication pages cannot be audited.

### ❓ Frequently Asked Questions

#### What is an on-page SEO audit?

An on-page SEO audit analyzes individual web pages to evaluate their optimization for search engines. It checks elements like titles, meta descriptions, headings, content structure, internal links, and technical metadata that influence search rankings.

#### How is the SEO score calculated?

The score starts at 100 and deducts points for each issue detected. Critical issues (missing title, multiple H1s, noindex) carry the heaviest penalties (10–20 pts). Warnings (short title, missing alt text) deduct 3–8 pts. Info items (missing OG tags, no JSON-LD) deduct 2–5 pts. The minimum score is 0.

#### Does this tool respect robots.txt?

Yes. The auditor fetches your site's `/robots.txt`, parses the rules, and automatically skips any disallowed paths. It also respects `Crawl-delay` directives for polite crawling.

#### Can I use this for competitor analysis?

This tool is designed for auditing domains you own. Auditing third-party sites without permission may violate their Terms of Service and robots.txt policies. Always verify you have the right to crawl a domain before using this tool.

#### What's the difference between on-page and technical SEO?

On-page SEO focuses on content and HTML source code optimizations (titles, meta, headings, schema). Technical SEO covers server configuration, site architecture, page speed, mobile optimization, crawlability, and indexation. This tool covers the on-page layer plus robots.txt/sitemap checks.

#### How many pages can I audit in one run?

You can audit up to 50 pages per run via the `maxPages` parameter. The default paths list includes 6 common pages (homepage, about, contact, blog, products, services).

#### Does this check Core Web Vitals?

Not directly. The auditor reports page size as a hint — oversized pages (>500 KB) are flagged. Actual Core Web Vitals (LCP, FID, CLS) require real user monitoring or lab tools like Lighthouse.

#### How long does a run take?

A typical audit of 1–6 pages completes in under 30 seconds. Larger audits (up to 50 pages) may take 2–5 minutes depending on server response times and crawl-delay settings.

### 📝 Changelog

- **0.1** — Initial release: title/meta/H1/canonical/hreflang/OG/Twitter/JSON-LD/link-check/alt-text/page-size/page-size audits, robots.txt compliance, sitemap detection, PPE pricing

### 🤝 Support

For issues, feature requests, or questions, visit the [actor page on Apify](https://apify.com/gp005/seo-onpage-auditor) or open an issue in the repository.

# Actor input Schema

## `domain` (type: `string`):

The root domain of the website you want to audit (e.g., example.com). Do NOT include protocol (https://) or paths. Must be a domain you own or have permission to crawl.

## `paths` (type: `array`):

List of URL paths to audit for on-page SEO signals. Defaults to key pages: homepage, about, contact, blog, products, services.

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

Maximum number of pages to crawl and audit (capped at 50).

## `timeoutSecs` (type: `integer`):

Timeout for each HTTP fetch and page load.

## Actor input object example

```json
{
  "domain": "your-awesome-site.com",
  "paths": [
    "/",
    "/about",
    "/contact"
  ],
  "maxPages": 10,
  "timeoutSecs": 15
}
```

# Actor output Schema

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

The fully qualified URL that was audited

## `statusCode` (type: `string`):

HTTP response status code of the page

## `score` (type: `string`):

Overall on-page SEO score (0-100), calculated from detected issues

## `pageTitle` (type: `string`):

Content of the <title> tag

## `titleLength` (type: `string`):

Character count of the page title

## `metaDescription` (type: `string`):

Content of the <meta name='description'> tag

## `metaDescriptionLength` (type: `string`):

Character count of the meta description

## `h1Tags` (type: `string`):

List of <h1> tag text content

## `h1Count` (type: `string`):

Number of <h1> tags found (should be exactly 1)

## `canonicalUrl` (type: `string`):

Value of <link rel='canonical'> href attribute

## `hreflangTags` (type: `string`):

List of hreflang annotations

## `openGraphTags` (type: `string`):

Open Graph meta tags (og:\*) as key-value pairs

## `twitterCardTags` (type: `string`):

Twitter Card meta tags (twitter:\*) as key-value pairs

## `metaRobots` (type: `string`):

Content of <meta name='robots'> tag, if present

## `jsonLdSchemas` (type: `string`):

Raw JSON-LD structured data blocks found on the page

## `internalLinks` (type: `string`):

Internal links with HTTP status checks

## `outboundLinks` (type: `string`):

Outbound/external links with HTTP status checks

## `imagesMissingAlt` (type: `string`):

Number of <img> elements without alt text

## `imagesWithAlt` (type: `string`):

Number of <img> elements with alt text

## `pageSizeBytes` (type: `string`):

Raw HTML size in bytes

## `issues` (type: `string`):

List of SEO issues found on the page

# 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 = {
    "domain": "example.com",
    "paths": [
        "/",
        "/about",
        "/contact",
        "/blog",
        "/products",
        "/services"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gp005/seo-onpage-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 = {
    "domain": "example.com",
    "paths": [
        "/",
        "/about",
        "/contact",
        "/blog",
        "/products",
        "/services",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("gp005/seo-onpage-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 '{
  "domain": "example.com",
  "paths": [
    "/",
    "/about",
    "/contact",
    "/blog",
    "/products",
    "/services"
  ]
}' |
apify call gp005/seo-onpage-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Technical On-Page SEO & Meta Auditor",
        "description": "Audit any website's on-page SEO: titles, meta descriptions, H1 tags, canonical URLs, hreflang, Open Graph, Twitter Cards, JSON-LD schema, broken links, image alt text, and robots compliance. Single polite crawl, first-party domains only.",
        "version": "0.1",
        "x-build-id": "6G6XzeiVZnkiUcpWr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gp005~seo-onpage-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gp005-seo-onpage-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/gp005~seo-onpage-auditor/runs": {
            "post": {
                "operationId": "runs-sync-gp005-seo-onpage-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/gp005~seo-onpage-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-gp005-seo-onpage-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domain"
                ],
                "properties": {
                    "domain": {
                        "title": "Domain to audit",
                        "type": "string",
                        "description": "The root domain of the website you want to audit (e.g., example.com). Do NOT include protocol (https://) or paths. Must be a domain you own or have permission to crawl."
                    },
                    "paths": {
                        "title": "Paths to crawl",
                        "type": "array",
                        "description": "List of URL paths to audit for on-page SEO signals. Defaults to key pages: homepage, about, contact, blog, products, services.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Maximum pages to audit",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl and audit (capped at 50).",
                        "default": 10
                    },
                    "timeoutSecs": {
                        "title": "Per-request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout for each HTTP fetch and page load.",
                        "default": 15
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
