# Federal Website Compliance Auditor — GSA Site Scanning API (`malonestar/gsa-site-scanning-auditor`) Actor

Audit 29,000+ federal .gov websites via the GSA Site Scanning API. Per-agency compliance scorecards (USWDS, DAP, HTTPS/HSTS, IPv6, mobile), flat site exports, and gap lists of sites missing a technology — instant govtech lead gen for vendors, auditors & journalists.

- **URL**: https://apify.com/malonestar/gsa-site-scanning-auditor.md
- **Developed by:** [Kyle Maloney](https://apify.com/malonestar) (community)
- **Categories:** Lead generation, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.75 / 1,000 results

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

## Federal Website Compliance Auditor — GSA Site Scanning API

Audit **29,000+ federal .gov websites** in one run. This actor turns GSA's official [Site Scanning API](https://open.gsa.gov/api/site-scanning-api/) — the same nightly scan engine behind digital.gov's dashboards — into three ready-to-use datasets:

1. **`scorecard`** (default) — one row per federal agency: site count, % compliant on each of 8 pillars (USWDS design system, DAP analytics, HTTPS enforcement, HSTS, IPv6, mobile viewport, sitemap.xml, robots.txt), a composite **0–100 compliance score**, and the agency's worst-offender domains.
2. **`sites`** — one flat row per website, filterable by agency, bureau, domain substring, and "must-fail" compliance filters (e.g. every site missing both DAP *and* USWDS).
3. **`gaps`** — the govtech lead-gen mode: one row per live site **failing a chosen pillar**, with agency, bureau, CMS, hosting provider, and traffic — a prospect list of agencies missing exactly the technology you sell.

No scraping, no headless browsers — pure official API, fast and reliable.

### Who is this for?

- **Govtech vendors & digital agencies** — `gaps` mode with `pillar: "dap"` or `"uswds"` is a qualified prospect list: agency, domain, current CMS, current host, and proof they're missing what you sell.
- **Federal web / compliance / CIO teams** — track your agency's 21st Century IDEA & OMB-mandate posture (USWDS, DAP, HTTPS) against every other agency.
- **Auditors & policy analysts** — reproducible per-agency compliance scorecards from official government scan data.
- **Journalists & researchers** — "Which agencies still don't enforce HTTPS?" answered in one run, with receipts.

### Quick start

Default run (no key needed — uses the shared `DEMO_KEY`) produces an agency scorecard for the General Services Administration:

```json
{
  "mode": "scorecard",
  "apiKey": "DEMO_KEY",
  "agencies": ["General Services Administration"],
  "maxResults": 1000
}
````

Lead-gen example — every live Interior Department site missing DAP analytics:

```json
{
  "mode": "gaps",
  "pillar": "dap",
  "apiKey": "YOUR_API_DATA_GOV_KEY",
  "agencies": ["Department of the Interior"],
  "maxResults": 2000
}
```

Full-government sweep (needs your own free key): leave `agencies` empty and set `maxResults: 20000`.

#### Get a free API key (30 seconds)

The prefilled `DEMO_KEY` works for small runs but is **shared and rate-limited across all anonymous users**. Register a free personal key at **https://api.data.gov/signup/** (1,000 requests/hour — enough to sweep all ~29,500 sites three times over) and paste it into `apiKey`. API docs: https://open.gsa.gov/api/site-scanning-api/. If the shared key hits HTTP 429, the actor logs a warning and emits partial results instead of failing.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | enum | `scorecard` | `scorecard` | `sites` | `gaps` |
| `apiKey` | string | `DEMO_KEY` | Free key from api.data.gov/signup |
| `agencies` | string\[] | all | Exact names use the API's server-side filter; partials match client-side |
| `pillar` | enum | `dap` | Gaps mode: `dap`, `uswds`, `https_enforced`, `hsts`, `ipv6`, `viewport_meta_tag`, `sitemap_xml`, `robots_txt` |
| `failingPillars` | enum\[] | — | Sites mode: only export sites failing **every** listed pillar |
| `domainContains` / `bureauContains` | string | — | Case-insensitive substring filters |
| `includeNonLive` | boolean | `false` | Include dead-DNS / unreachable catalogue entries |
| `maxResults` | integer | 2000 | Caps sites fetched (100/request) and rows pushed; up to 20,000 |

### Output fields

Every row has `row_type` (`agency_scorecard`, `site`, or `gap`).

- **Scorecard rows:** `agency`, `total_sites`, `uswds_pct`, `dap_pct`, `https_enforced_pct`, `hsts_pct`, `ipv6_pct`, `viewport_meta_tag_pct`, `sitemap_xml_pct`, `robots_txt_pct`, `compliance_score` (0–100 composite), `worst_offenders` (top-5 domains by failed pillars). Percentages count only sites where the pillar was actually measured.
- **Site rows:** `domain`, `url`, `agency`, `bureau`, `branch`, `live`, `status_code`, `cms`, `cloud_provider`, `uswds`, `uswds_count`, `dap`, `dap_version`, `https_enforced`, `hsts`, `ipv6`, `viewport_meta_tag`, `sitemap_xml_detected`, `robots_txt_detected`, `third_party_service_count`, `login_provider`, `site_search`, `pageviews`, `visits`, `scan_date`, `failed_pillars`.
- **Gap rows:** `pillar`, `domain`, `url`, `agency`, `bureau`, `cms`, `cloud_provider`, `status_code`, `pageviews`, `visits`, `failed_pillars`, `scan_date`.

### Use as an MCP tool

This actor works as a clean, chainable **MCP tool** for AI agents (Claude, Cursor, custom agents) via [mcp.apify.com](https://mcp.apify.com). The input schema is fully described field-by-field, so an agent can ask things like *"score every agency's website compliance"* or *"list Department of Energy sites without DAP analytics"* and get structured rows back — ready to chain into CRM enrichment, report generation, or outreach drafting.

### FAQ

**Where does the data come from?** GSA's Site Scanning program (`api.gsa.gov/technology/site-scanning/v1`), which rescans every known federal website roughly daily. `scan_date` on each row shows freshness.

**Do I need an API key?** No — `DEMO_KEY` works out of the box. But it's shared by everyone, so for full sweeps register a free key at https://api.data.gov/signup/ (instant, no approval).

**What counts as "USWDS detected"?** The site exposes `usa-` CSS classes or scores ≥ 50 on GSA's cumulative USWDS heuristic (`uswds_count`).

**Why don't scorecard percentages include every site?** Sites the scanner couldn't measure for a pillar (e.g. DNS failures) are excluded from that pillar's denominator, so scores reflect real measurements, not gaps in coverage. By default only `live: true` sites are analyzed at all (`includeNonLive` overrides).

**Is there a security.txt pillar?** Not currently — the v1 API does not expose a security.txt field. The 8 pillars cover USWDS, DAP, HTTPS, HSTS, IPv6, mobile viewport, sitemap, and robots.txt.

**Can it audit state or local government sites?** No — the underlying scan covers the federal web presence (~29,500 sites across executive, legislative, and judicial branches).

**How is it priced?** Pay-per-event: you pay a small fee per dataset row. A scorecard for one agency is a handful of rows; a full-government gap list is a few thousand.

# Actor input Schema

## `mode` (type: `string`):

What to output. 'scorecard' (default) = one row per agency with % compliant per pillar + composite 0-100 compliance score + worst offender domains. 'sites' = one flat row per website (filterable). 'gaps' = one row per site FAILING the chosen pillar — a ready-made govtech prospect list.

## `apiKey` (type: `string`):

Your free api.data.gov key (register in 30 seconds at https://api.data.gov/signup/ — 1,000 requests/hour). The prefilled shared DEMO\_KEY works for small runs but is rate-limited across all anonymous users; on HTTP 429 the actor emits partial results instead of failing.

## `agencies` (type: `array`):

Optional list of federal agency names to audit, e.g. \["General Services Administration", "Department of the Interior"]. Exact names use the API's fast server-side filter; partial names are matched case-insensitively client-side. Leave empty to sweep all agencies (raise maxResults for full coverage).

## `pillar` (type: `string`):

Which compliance pillar to prospect on in 'gaps' mode: every output row is a live site FAILING this check. 'dap' = missing Digital Analytics Program tag; 'uswds' = not using the US Web Design System; others cover HTTPS enforcement, HSTS, IPv6, mobile viewport, sitemap.xml, robots.txt. Ignored in other modes.

## `failingPillars` (type: `array`):

Optional compliance filters for 'sites' mode: only export sites that FAIL every listed pillar. Allowed values: dap, uswds, https\_enforced, hsts, ipv6, viewport\_meta\_tag, sitemap\_xml, robots\_txt. Example: \["dap", "uswds"] returns sites missing both DAP and USWDS. Ignored in other modes.

## `domainContains` (type: `string`):

Optional case-insensitive substring filter on the site URL/domain, e.g. "va.gov" or "nasa". Applied client-side after fetching.

## `bureauContains` (type: `string`):

Optional case-insensitive substring filter on the bureau name, e.g. "Forest Service". Applied client-side after fetching.

## `includeNonLive` (type: `boolean`):

By default only live, fully scanned websites are analyzed (dead DNS / unreachable hosts are skipped so they cannot drag scores down). Set true to include every catalogued record.

## `maxResults` (type: `integer`):

Caps both sites fetched from the API (100 per request) and rows pushed to the dataset. Default 2000. Prefill 1000 keeps default runs comfortably inside DEMO\_KEY rate limits; with your own free key you can raise it to 20000+ to sweep all ~29,500 federal sites in ~300 requests.

## Actor input object example

```json
{
  "mode": "scorecard",
  "apiKey": "DEMO_KEY",
  "agencies": [
    "General Services Administration"
  ],
  "pillar": "dap",
  "includeNonLive": false,
  "maxResults": 1000
}
```

# Actor output Schema

## `results` (type: `string`):

The default dataset of compliance rows.

# 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 = {
    "mode": "scorecard",
    "apiKey": "DEMO_KEY",
    "agencies": [
        "General Services Administration"
    ],
    "pillar": "dap",
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/gsa-site-scanning-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 = {
    "mode": "scorecard",
    "apiKey": "DEMO_KEY",
    "agencies": ["General Services Administration"],
    "pillar": "dap",
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("malonestar/gsa-site-scanning-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 '{
  "mode": "scorecard",
  "apiKey": "DEMO_KEY",
  "agencies": [
    "General Services Administration"
  ],
  "pillar": "dap",
  "maxResults": 1000
}' |
apify call malonestar/gsa-site-scanning-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Website Compliance Auditor — GSA Site Scanning API",
        "description": "Audit 29,000+ federal .gov websites via the GSA Site Scanning API. Per-agency compliance scorecards (USWDS, DAP, HTTPS/HSTS, IPv6, mobile), flat site exports, and gap lists of sites missing a technology — instant govtech lead gen for vendors, auditors & journalists.",
        "version": "1.0",
        "x-build-id": "oN1hqsyvLEVQzljHO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/malonestar~gsa-site-scanning-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-malonestar-gsa-site-scanning-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/malonestar~gsa-site-scanning-auditor/runs": {
            "post": {
                "operationId": "runs-sync-malonestar-gsa-site-scanning-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/malonestar~gsa-site-scanning-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-malonestar-gsa-site-scanning-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "scorecard",
                            "sites",
                            "gaps"
                        ],
                        "type": "string",
                        "description": "What to output. 'scorecard' (default) = one row per agency with % compliant per pillar + composite 0-100 compliance score + worst offender domains. 'sites' = one flat row per website (filterable). 'gaps' = one row per site FAILING the chosen pillar — a ready-made govtech prospect list."
                    },
                    "apiKey": {
                        "title": "api.data.gov API key",
                        "type": "string",
                        "description": "Your free api.data.gov key (register in 30 seconds at https://api.data.gov/signup/ — 1,000 requests/hour). The prefilled shared DEMO_KEY works for small runs but is rate-limited across all anonymous users; on HTTP 429 the actor emits partial results instead of failing."
                    },
                    "agencies": {
                        "title": "Agencies",
                        "type": "array",
                        "description": "Optional list of federal agency names to audit, e.g. [\"General Services Administration\", \"Department of the Interior\"]. Exact names use the API's fast server-side filter; partial names are matched case-insensitively client-side. Leave empty to sweep all agencies (raise maxResults for full coverage).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pillar": {
                        "title": "Gap pillar (gaps mode)",
                        "enum": [
                            "dap",
                            "uswds",
                            "https_enforced",
                            "hsts",
                            "ipv6",
                            "viewport_meta_tag",
                            "sitemap_xml",
                            "robots_txt"
                        ],
                        "type": "string",
                        "description": "Which compliance pillar to prospect on in 'gaps' mode: every output row is a live site FAILING this check. 'dap' = missing Digital Analytics Program tag; 'uswds' = not using the US Web Design System; others cover HTTPS enforcement, HSTS, IPv6, mobile viewport, sitemap.xml, robots.txt. Ignored in other modes."
                    },
                    "failingPillars": {
                        "title": "Must-fail filters (sites mode)",
                        "type": "array",
                        "description": "Optional compliance filters for 'sites' mode: only export sites that FAIL every listed pillar. Allowed values: dap, uswds, https_enforced, hsts, ipv6, viewport_meta_tag, sitemap_xml, robots_txt. Example: [\"dap\", \"uswds\"] returns sites missing both DAP and USWDS. Ignored in other modes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "dap",
                                "uswds",
                                "https_enforced",
                                "hsts",
                                "ipv6",
                                "viewport_meta_tag",
                                "sitemap_xml",
                                "robots_txt"
                            ],
                            "enumTitles": [
                                "Missing DAP analytics",
                                "No USWDS design system",
                                "HTTPS not enforced",
                                "No HSTS",
                                "No IPv6",
                                "No mobile viewport tag",
                                "No sitemap.xml",
                                "No robots.txt"
                            ]
                        }
                    },
                    "domainContains": {
                        "title": "Domain contains",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter on the site URL/domain, e.g. \"va.gov\" or \"nasa\". Applied client-side after fetching."
                    },
                    "bureauContains": {
                        "title": "Bureau contains",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter on the bureau name, e.g. \"Forest Service\". Applied client-side after fetching."
                    },
                    "includeNonLive": {
                        "title": "Include non-live sites",
                        "type": "boolean",
                        "description": "By default only live, fully scanned websites are analyzed (dead DNS / unreachable hosts are skipped so they cannot drag scores down). Set true to include every catalogued record.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Caps both sites fetched from the API (100 per request) and rows pushed to the dataset. Default 2000. Prefill 1000 keeps default runs comfortably inside DEMO_KEY rate limits; with your own free key you can raise it to 20000+ to sweep all ~29,500 federal sites in ~300 requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```