# Wayback Machine Search (`maximedupre/wayback-machine-search`) Actor

Search Wayback Machine snapshots for URLs, hosts, and domains. Export archive dates, status codes, MIME types, digests, content text, version timelines, reports, and monitoring alerts.

- **URL**: https://apify.com/maximedupre/wayback-machine-search.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (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 $0.90 / 1,000 saved archive 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.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

### 🕰️ Wayback Machine search for archive history

Wayback Machine Search finds historical snapshots in the [Internet Archive Wayback Machine](https://web.archive.org/) for the URLs, hosts, or domains you submit. Use it to export archive dates, original URLs, HTTP status codes, MIME types, content digests, content length, optional archived page text, version timelines, Markdown reports, and monitoring alerts.

It is built for SEO audits, OSINT research, legal evidence checks, website change tracking, link-rot recovery, content history reviews, and scheduled archive monitoring. You can start with one URL such as `https://example.com/`, a bare domain such as `example.com`, or up to 50 targets in one run. No Wayback Machine API key, cookies, login, or user proxy setup is required.

### 🔎 What this Actor does

- Searches the Wayback Machine CDX index for exact URLs, URL prefixes, hosts, or full domains.
- Filters archive rows by date range, HTTP status code, and MIME type.
- Saves raw snapshot rows with source-backed archive metadata.
- Collapses repeated captures by content digest or by month, day, or hour.
- Finds snapshots closest to a target date and adds distance in days.
- Optionally fetches readable archived page text for a capped number of snapshots.
- Emits deterministic change evidence from status, digest, length, and fetched text changes.
- Builds version timeline rows when you want a compact history.
- Generates a Markdown report in report mode.
- Supports monitoring mode with alert rows for new archive rows, status changes, content changes, or removed/restored signals.

This Actor searches archive data. It does not crawl the live web, create new Wayback captures, perform visual screenshot diffs, use AI summaries, or promise complete archive coverage. Availability depends on what the Internet Archive has stored.

### 📦 Data you get

Snapshot rows can include:

- `target` - submitted URL or domain that produced the row
- `originalUrl` - original archived URL from the Wayback capture
- `waybackTimestamp` and `archiveDate` - source timestamp and ISO date
- `statusCode`, `mimeType`, `contentDigest`, and `contentLength`
- `contentStatus` and optional `content` when archived text is fetched
- `distanceFromTargetDays` for closest-date evidence
- `change` evidence with the previous timestamp and source-backed reason

Version rows group consecutive captures into timeline intervals. Summary rows report per-target coverage, counts, date range, discovered paths, subdomains, and emails found in fetched content. Alert rows appear in monitoring mode only when the selected mechanical alert rule is met.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or consume the rows through the Apify API, schedules, webhooks, and integrations.

### 🚀 How to run it

1. Add one or more URLs or domains in **URLs or domains**.
2. Choose **Archive scope**: exact URL, URL prefix, same host, or same domain and subdomains.
3. Set optional date, status, and MIME filters.
4. Pick an output mode: raw snapshots, changed snapshots, timeline, closest snapshot to date, Markdown report, or monitoring delta.
5. Keep **Collapse snapshots by** on content digest for compact results, or choose every snapshot for full raw history.
6. Turn on **Fetch archived page text** only when you need readable content or phrase search evidence.
7. Run the Actor and open the dataset or optional Markdown report.

For a small first run, use:

```json
{
	"targets": ["example.com"],
	"matchType": "domain",
	"maxResults": 10,
	"statusFilter": "200",
	"mimeFilter": "text/html",
	"outputMode": "snapshots",
	"collapseBy": "digest",
	"includeContent": false
}
````

### ⚙️ Input options

`targets` is required and accepts up to 50 URLs or domains.

`matchType` controls how broadly each target is searched. Use exact URL for one page, prefix for a path, host for one hostname, and domain when subdomains should be included.

`maxResults` limits saved snapshot, version, or alert rows per target. The maximum is 10,000.

`dateFrom` and `dateTo` accept `YYYY`, `YYYYMM`, or `YYYYMMDD`. `statusFilter` accepts a status such as `200` or `404`. `mimeFilter` accepts a type such as `text/html`.

`outputMode` changes the result shape. Use raw snapshots for exports, timeline for version intervals, closest snapshot to date for evidence work, report for a Markdown summary, and monitoring for scheduled archive checks.

`includeContent`, `maxContentFetch`, and `historyQuery` control archived text fetching. Content fetching is capped so large archive searches do not fetch every historical page by accident.

### 🧾 Output example

```json
{
	"recordType": "snapshot",
	"target": "example.com",
	"originalUrl": "https://example.com/pricing",
	"waybackTimestamp": "20240510123045",
	"archiveDate": "2024-05-10T12:30:45.000Z",
	"statusCode": 200,
	"mimeType": "text/html",
	"contentDigest": "M5W6TLBPLQWJXTQWJ2R5XQ7Y3YQK4K6L",
	"contentLength": 18432,
	"contentStatus": "notRequested",
	"content": null,
	"distanceFromTargetDays": null,
	"change": {
		"changed": true,
		"type": "digestChange",
		"previousArchiveDate": "2024-04-01T08:15:30.000Z",
		"previousWaybackTimestamp": "20240401081530",
		"evidence": ["Digest changed from ABC123 to M5W6TLBPLQWJXTQWJ2R5XQ7Y3YQK4K6L"]
	},
	"version": null,
	"diff": null,
	"summary": null,
	"alert": null
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each saved successful Wayback result: snapshot, version, summary, or monitoring alert. Empty archive searches, invalid inputs, skipped content fetches, and source issues do not create dataset rows.

The planned pricing starts at `$0.0018` per saved archive result on the Free tier and goes down to `$0.0009` per saved archive result on higher tiers. Always check the Actor Pricing tab before starting a large run.

### ⚠️ Limits and caveats

- The Internet Archive may not have snapshots for every page or date.
- A successful run can return zero rows when no matching archive data exists.
- Archive text can be unavailable, non-HTML, capped, or skipped by the content fetch limit.
- Monitoring compares the latest saved archive state for the same target and filters. It is based on Wayback captures, not live website polling.
- Change labels are mechanical and source-backed. They do not claim semantic meaning such as a product, legal, or pricing change unless the returned text evidence shows it.

### ❓ FAQ

#### ❓ Does this use the official Wayback Machine?

It reads public Internet Archive Wayback Machine data through the CDX index and archived playback pages.

#### 🔑 Do I need a Wayback Machine API key?

No. The Actor does not ask for a Wayback Machine API key, cookies, or login.

#### 📡 Can it monitor a live website?

It monitors changes in Wayback Machine archive captures. It does not poll the current live page independently.

#### 🔗 Why is there no `archiveUrl` field?

Rows keep `originalUrl` and `waybackTimestamp`. A playback URL can be reconstructed as `https://web.archive.org/web/{waybackTimestamp}/{originalUrl}` when you need to open the archived page.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~wayback-machine-search/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Sitemap Sniffer ↗](https://apify.com/maximedupre/sitemap-sniffer) - Find public sitemap files and URL inventories before an archive or SEO audit.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Crawl rendered website links and export a clean link map.
- [SEMrush Free Website Stats Scraper ↗](https://apify.com/maximedupre/semrush-free-website-stats-scraper) - Collect public domain traffic, authority, backlink, and referral metrics.
- [Ahrefs Free Website Stats Scraper ↗](https://apify.com/maximedupre/ahrefs-free-website-stats-scraper) - Export public Ahrefs domain rating, traffic, rank, and linking website stats.
- [Font Detector ↗](https://apify.com/maximedupre/font-detector) - Detect fonts, CSS families, and source evidence on public web pages.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter each URL or domain to search in the Wayback Machine.

## `matchType` (type: `string`):

Choose how broadly each target should match archived URLs.

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

Maximum snapshot, version, or event rows to save per target.

## `dateFrom` (type: `string`):

Earliest archive date to include. Use YYYY, YYYYMM, or YYYYMMDD.

## `dateTo` (type: `string`):

Latest archive date to include. Use YYYY, YYYYMM, or YYYYMMDD.

## `statusFilter` (type: `string`):

Save snapshots with this status code, such as 200 or 404.

## `mimeFilter` (type: `string`):

Save snapshots with this content type, such as text/html.

## `outputMode` (type: `string`):

Choose whether rows focus on raw snapshots, changes, versions, evidence, reports, or monitoring.

## `collapseBy` (type: `string`):

Group repeated captures by content digest or time bucket.

## `targetDate` (type: `string`):

Date for closest-date evidence rows.

## `historyQuery` (type: `string`):

Find when this phrase appears in fetched archived text.

## `includeContent` (type: `boolean`):

Adds readable archived text for capped snapshots.

## `maxContentFetch` (type: `integer`):

Maximum archived pages to fetch as readable text per run.

## `alertOn` (type: `string`):

Choose which mechanical change should emit alert rows.

## Actor input object example

```json
{
  "targets": [
    "example.com"
  ],
  "matchType": "domain",
  "maxResults": 32,
  "statusFilter": "200",
  "mimeFilter": "text/html",
  "outputMode": "report",
  "collapseBy": "none",
  "includeContent": true,
  "maxContentFetch": 32,
  "alertOn": "statusOrContent"
}
```

# Actor output Schema

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

Dataset rows for archived snapshots, version timelines, report summaries, and monitoring alerts, depending on the selected output mode.

## `report` (type: `string`):

Markdown report generated when Output mode is set to Markdown report.

# 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 = {
    "targets": [
        "example.com"
    ],
    "dateFrom": "",
    "dateTo": "",
    "statusFilter": "200",
    "mimeFilter": "text/html",
    "targetDate": "",
    "historyQuery": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/wayback-machine-search").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 = {
    "targets": ["example.com"],
    "dateFrom": "",
    "dateTo": "",
    "statusFilter": "200",
    "mimeFilter": "text/html",
    "targetDate": "",
    "historyQuery": "",
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/wayback-machine-search").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 '{
  "targets": [
    "example.com"
  ],
  "dateFrom": "",
  "dateTo": "",
  "statusFilter": "200",
  "mimeFilter": "text/html",
  "targetDate": "",
  "historyQuery": ""
}' |
apify call maximedupre/wayback-machine-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wayback Machine Search",
        "description": "Search Wayback Machine snapshots for URLs, hosts, and domains. Export archive dates, status codes, MIME types, digests, content text, version timelines, reports, and monitoring alerts.",
        "version": "0.1",
        "x-build-id": "ONxaFEMKoykJ2XRWU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~wayback-machine-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-wayback-machine-search",
                "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/maximedupre~wayback-machine-search/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-wayback-machine-search",
                "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/maximedupre~wayback-machine-search/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-wayback-machine-search",
                "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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "URLs or domains",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Enter each URL or domain to search in the Wayback Machine.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "matchType": {
                        "title": "Archive scope",
                        "enum": [
                            "exact",
                            "prefix",
                            "host",
                            "domain"
                        ],
                        "type": "string",
                        "description": "Choose how broadly each target should match archived URLs.",
                        "default": "domain"
                    },
                    "maxResults": {
                        "title": "Maximum archive rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum snapshot, version, or event rows to save per target.",
                        "default": 32
                    },
                    "dateFrom": {
                        "title": "From archive date",
                        "type": "string",
                        "description": "Earliest archive date to include. Use YYYY, YYYYMM, or YYYYMMDD."
                    },
                    "dateTo": {
                        "title": "To archive date",
                        "type": "string",
                        "description": "Latest archive date to include. Use YYYY, YYYYMM, or YYYYMMDD."
                    },
                    "statusFilter": {
                        "title": "HTTP status",
                        "type": "string",
                        "description": "Save snapshots with this status code, such as 200 or 404."
                    },
                    "mimeFilter": {
                        "title": "MIME type",
                        "type": "string",
                        "description": "Save snapshots with this content type, such as text/html."
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "snapshots",
                            "changes",
                            "timeline",
                            "closestDate",
                            "report",
                            "monitoring"
                        ],
                        "type": "string",
                        "description": "Choose whether rows focus on raw snapshots, changes, versions, evidence, reports, or monitoring.",
                        "default": "report"
                    },
                    "collapseBy": {
                        "title": "Collapse snapshots by",
                        "enum": [
                            "digest",
                            "monthly",
                            "daily",
                            "hourly",
                            "none"
                        ],
                        "type": "string",
                        "description": "Group repeated captures by content digest or time bucket.",
                        "default": "none"
                    },
                    "targetDate": {
                        "title": "Target date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Date for closest-date evidence rows."
                    },
                    "historyQuery": {
                        "title": "History search phrase",
                        "type": "string",
                        "description": "Find when this phrase appears in fetched archived text."
                    },
                    "includeContent": {
                        "title": "Fetch archived page text",
                        "type": "boolean",
                        "description": "Adds readable archived text for capped snapshots.",
                        "default": true
                    },
                    "maxContentFetch": {
                        "title": "Maximum content fetches",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum archived pages to fetch as readable text per run.",
                        "default": 32
                    },
                    "alertOn": {
                        "title": "Alert on",
                        "enum": [
                            "none",
                            "anyNewArchiveRow",
                            "statusChange",
                            "contentChange",
                            "statusOrContent",
                            "pageRemovedOrRestored"
                        ],
                        "type": "string",
                        "description": "Choose which mechanical change should emit alert rows.",
                        "default": "statusOrContent"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```