# US Travel Advisories Scraper (`automation-lab/us-travel-advisories-scraper`) Actor

Scrape official U.S. State Department travel advisory levels, issue dates, risk indicators, summaries, and country detail URLs.

- **URL**: https://apify.com/automation-lab/us-travel-advisories-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## US Travel Advisories Scraper

Scrape U.S. State Department travel advisory data from Travel.State.Gov and turn it into structured records for risk, compliance, and travel operations workflows.

The actor extracts destination names, advisory levels, issue dates, risk indicators, detail URLs, and optional advisory summaries from public State Department pages.

Use it to monitor country risk changes, enrich travel-risk dashboards, power duty-of-care alerts, or keep a clean archive of official U.S. travel advisory updates.

### What does US Travel Advisories Scraper do?

US Travel Advisories Scraper reads the public State Department travel advisories listing and saves one dataset item per destination.

It can run in two modes:

- ⚡ **Listing mode** for fast country, level, risk tag, date, and URL extraction.
- 🔎 **Detail mode** for advisory guidance, summary text, and last-updated enrichment.

The default input is ready to run against the official advisory index.

### Who is it for?

This scraper is useful for teams that need official travel-risk data in repeatable formats.

- 🧭 Travel-risk platforms tracking destination status.
- 🏢 Corporate security and duty-of-care teams.
- 🧾 Compliance teams checking travel policy exceptions.
- 🛫 Travel agencies and trip-planning tools.
- 🛡️ Insurers and assistance providers.
- 📊 Data teams building country risk dashboards.

### Why use this scraper?

The State Department website is designed for human readers. This actor converts the advisory table into clean machine-readable rows.

Benefits include:

- Official source URLs for every record.
- Normalized issue dates for filtering and joins.
- Numeric advisory levels for dashboards.
- Risk indicator arrays for tagging and search.
- Optional detail summaries for downstream alerts.
- Recurring runs for change monitoring.

### What data can you extract?

Each output item can include:

| Field | Description |
| --- | --- |
| `country` | Destination name from the advisory table. |
| `advisoryLevel` | Numeric advisory level from 1 to 4. |
| `advisoryLevelText` | Full level label, such as `Level 4: Do not travel`. |
| `dateIssued` | Raw issued date from Travel.State.Gov. |
| `dateIssuedIso` | Normalized issued date in `YYYY-MM-DD` format. |
| `riskIndicators` | Risk pills such as crime, terrorism, health, unrest, or natural disaster. |
| `detailUrl` | Official detail page URL. |
| `guidance` | Detail-page guidance text when available. |
| `summary` | Advisory summary or page summary. |
| `lastUpdatedIso` | Normalized detail-page last-updated date when available. |
| `scrapedAt` | Timestamp for the actor run. |

### How much does it cost to scrape US travel advisories?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-item fee for each advisory record saved. Platform billing uses your Apify subscription tier; the current per-record event is `ADVISORY_SCRAPED`.

| Example run | Records | Approximate FREE-tier actor fee | Approximate BRONZE-tier actor fee |
| --- | ---: | ---: | ---: |
| Quick sample | 20 | $0.0056 | $0.0055 |
| Country watchlist | 50 | $0.0066 | $0.0064 |
| Full listing snapshot | 120 | $0.0087 | $0.0083 |
| Daily full listing for 30 days | 3,600 | $0.1172 | $0.1025 |

These examples use the configured $0.005 run-start fee plus the current per-record tier prices from the actor configuration. They exclude any separate Apify platform compute or proxy costs charged by Apify to your account.

The Apify free plan can usually cover many lightweight listing-mode test runs because the source is public HTML and does not require a browser. For example, 120 advisory records costs under one cent in actor event fees at the FREE tier.

For production monitoring, set `maxItems` high enough to cover the full advisory table and run the actor on a schedule.

### Input options

The input schema supports simple monitoring workflows.

- `startUrl` — State Department advisory listing URL.
- `countryNames` — optional exact destination names to keep.
- `advisoryLevels` — optional numeric level filters from 1 to 4.
- `maxItems` — maximum number of advisory records to save.
- `includeDetails` — fetch country detail pages for summaries and guidance.
- `changedSince` — keep records issued on or after a date.

### Example input

```json
{
  "startUrl": "https://travel.state.gov/en/international-travel/travel-advisories.html",
  "maxItems": 100,
  "includeDetails": true
}
````

### Country watchlist input

```json
{
  "countryNames": ["Mexico", "France", "Japan"],
  "maxItems": 25,
  "includeDetails": true
}
```

### Level 4 monitoring input

```json
{
  "advisoryLevels": [4],
  "maxItems": 100,
  "includeDetails": true
}
```

### Output example

```json
{
  "country": "Afghanistan",
  "advisoryLevel": 4,
  "advisoryLevelText": "Level 4: Do not travel",
  "dateIssued": "02/20/2026",
  "dateIssuedIso": "2026-02-20",
  "riskIndicators": ["UNREST (U)", "CRIME (C)", "HEALTH (H)"],
  "detailUrl": "https://travel.state.gov/en/international-travel/travel-advisories/afghanistan.html",
  "guidance": "Do not travel due to civil unrest, crime, terrorism...",
  "summary": "Do not travel to Afghanistan for any reason...",
  "lastUpdatedIso": "2026-04-02",
  "scrapedAt": "2026-06-27T00:00:00.000Z"
}
```

### How to run the scraper

1. Open the actor on Apify.
2. Keep the default advisory listing URL.
3. Choose whether to include detail summaries.
4. Add country or level filters if needed.
5. Set `maxItems`.
6. Start the run.
7. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for reliable monitoring

- Use listing mode (`includeDetails: false`) for the fastest daily checks.
- Use detail mode when alerts need human-readable guidance and summary text.
- Filter with `countryNames` for corporate travel watchlists.
- Filter with `advisoryLevels` for high-risk security queues.
- Use `changedSince` to focus a recurring workflow on recently issued advisories.

### Integrations

Typical integrations include:

- Send Level 4 advisory rows into Slack or Teams.
- Store full advisory snapshots in a data warehouse.
- Compare scheduled run datasets to identify changed issue dates.
- Enrich traveler booking records with destination risk level.
- Feed compliance dashboards with risk indicators.
- Trigger human review when a country moves to Level 3 or Level 4.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/us-travel-advisories-scraper').call({
  maxItems: 100,
  includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/us-travel-advisories-scraper').call(run_input={
    'maxItems': 100,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~us-travel-advisories-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"includeDetails":true}'
```

### MCP usage

You can connect this actor to AI tools through Apify MCP.

Use this MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/us-travel-advisories-scraper
```

Add it to Claude Code with the HTTP transport explicitly set:

```bash
claude mcp add apify-travel-advisories --transport http https://mcp.apify.com/?tools=automation-lab/us-travel-advisories-scraper
```

For Claude Desktop, Cursor, VS Code, or another MCP client, add the same HTTP server URL to the client's MCP server JSON/settings. Use an Apify API token in the client environment if your workflow requires authenticated actor runs.

Or configure an MCP client with JSON:

```json
{
  "mcpServers": {
    "apify-travel-advisories": {
      "url": "https://mcp.apify.com/?tools=automation-lab/us-travel-advisories-scraper"
    }
  }
}
```

Example prompts:

- "Run the US Travel Advisories Scraper for Level 4 countries and summarize changes."
- "Get advisories for Mexico, Japan, and France and format them for a travel-risk memo."
- "Extract all State Department risk indicators into a table by country."

### Change monitoring workflow

For recurring monitoring:

1. Schedule the actor daily or weekly.
2. Keep `maxItems` high enough for the full table.
3. Store each dataset snapshot.
4. Compare `country`, `advisoryLevel`, and `dateIssuedIso` between runs.
5. Alert when a watched country changes level or receives a new issued date.

### Data source

The actor uses public pages from Travel.State.Gov, including the travel advisories table and destination detail pages.

It does not log in, bypass private systems, or access non-public data.

### Limitations

- The actor depends on the public State Department page structure.
- Some destination links point to country information pages rather than advisory-only pages.
- Detail summaries are best-effort and may be unavailable for some destinations.
- Advisory interpretation should be reviewed by qualified travel-risk professionals.

### Legality

This actor extracts publicly available government information.

You are responsible for using the data in accordance with applicable laws, platform terms, and your organization's compliance requirements.

Do not use scraped data as the sole basis for safety decisions without reviewing the official source pages.

### FAQ

#### Is this an official State Department API?

No. This is an Apify actor that extracts public Travel.State.Gov pages into a structured dataset. Always keep the official detail URL with downstream records.

#### Can I monitor only high-risk countries?

Yes. Set `advisoryLevels` to `[3, 4]` or `[4]` and run the actor on a schedule.

### Troubleshooting

#### Why did I get fewer rows than expected?

Check `maxItems`, `countryNames`, `advisoryLevels`, and `changedSince`. Filters are applied before saving items.

#### Why is `summary` empty for some destinations?

Some links point to country information pages or pages without the same advisory component. The actor still saves listing fields and URLs.

#### Should I enable detail mode?

Enable detail mode when you need guidance or summary text. Disable it for fast table snapshots.

### Related scrapers

You may also want other Automation Lab actors for travel, government, compliance, or alert monitoring workflows:

- `automation-lab/cdc-travel-health-notices-scraper`
- `automation-lab/nps-park-conditions-alerts-api-scraper`
- `automation-lab/world-bank-projects-scraper`
- `automation-lab/samgov-government-contracts-scraper`

### Support

If the State Department changes the advisory page layout and extraction breaks, open an issue with a run link and a sample expected country.

### Changelog

- Initial version extracts advisory listing rows and optional detail summaries.

# Actor input Schema

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

State Department listing page to scrape. Keep the default unless the website changes its advisory index URL.

## `countryNames` (type: `array`):

Optional exact country or destination names to keep, for example Afghanistan, Mexico, France. Leave empty to scrape all advisory rows.

## `advisoryLevels` (type: `array`):

Optional advisory levels to keep. 1 = normal precautions, 2 = increased caution, 3 = reconsider travel, 4 = do not travel.

## `maxItems` (type: `integer`):

Maximum advisory records to save. Use a small value for tests or raise to 250 to collect the full listing.

## `includeDetails` (type: `boolean`):

Fetch each country detail page to extract advisory guidance, summary text, and last updated date. Disable for fastest listing-only monitoring.

## `changedSince` (type: `string`):

Optional date filter for change monitoring. Keeps advisories issued on or after this date. Accepts YYYY-MM-DD or MM/DD/YYYY.

## Actor input object example

```json
{
  "startUrl": "https://travel.state.gov/en/international-travel/travel-advisories.html",
  "countryNames": [
    "Afghanistan",
    "Mexico"
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrl": "https://travel.state.gov/en/international-travel/travel-advisories.html",
    "countryNames": [
        "Afghanistan",
        "Mexico"
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/us-travel-advisories-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrl": "https://travel.state.gov/en/international-travel/travel-advisories.html",
    "countryNames": [
        "Afghanistan",
        "Mexico",
    ],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/us-travel-advisories-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrl": "https://travel.state.gov/en/international-travel/travel-advisories.html",
  "countryNames": [
    "Afghanistan",
    "Mexico"
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/us-travel-advisories-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/us-travel-advisories-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Travel Advisories Scraper",
        "description": "Scrape official U.S. State Department travel advisory levels, issue dates, risk indicators, summaries, and country detail URLs.",
        "version": "0.1",
        "x-build-id": "Krf8Z1vbhIAqPSWX4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~us-travel-advisories-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-us-travel-advisories-scraper",
                "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/automation-lab~us-travel-advisories-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-us-travel-advisories-scraper",
                "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/automation-lab~us-travel-advisories-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-us-travel-advisories-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrl": {
                        "title": "Travel advisories listing URL",
                        "type": "string",
                        "description": "State Department listing page to scrape. Keep the default unless the website changes its advisory index URL.",
                        "default": "https://travel.state.gov/en/international-travel/travel-advisories.html"
                    },
                    "countryNames": {
                        "title": "Country / destination filters",
                        "type": "array",
                        "description": "Optional exact country or destination names to keep, for example Afghanistan, Mexico, France. Leave empty to scrape all advisory rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "advisoryLevels": {
                        "title": "Advisory levels",
                        "type": "array",
                        "description": "Optional advisory levels to keep. 1 = normal precautions, 2 = increased caution, 3 = reconsider travel, 4 = do not travel.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 4
                        }
                    },
                    "maxItems": {
                        "title": "Maximum advisories",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum advisory records to save. Use a small value for tests or raise to 250 to collect the full listing.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include detail summaries",
                        "type": "boolean",
                        "description": "Fetch each country detail page to extract advisory guidance, summary text, and last updated date. Disable for fastest listing-only monitoring.",
                        "default": false
                    },
                    "changedSince": {
                        "title": "Issued since date",
                        "type": "string",
                        "description": "Optional date filter for change monitoring. Keeps advisories issued on or after this date. Accepts YYYY-MM-DD or MM/DD/YYYY."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```