# USGS Volcano Activity Notifications Scraper (`automation-lab/usgs-volcano-activity-notifications-scraper`) Actor

Scrape official USGS HANS volcano notices, alert levels, aviation color codes, observatories, timestamps, VNUMs, summaries, and URLs.

- **URL**: https://apify.com/automation-lab/usgs-volcano-activity-notifications-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** News
- **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/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

## USGS Volcano Activity Notifications Scraper

Turn the public USGS HANS volcano notification page into clean, structured data.

This Apify Actor extracts volcano activity notices, VONA notices, alert levels, aviation color codes, observatories, sent timestamps, detail-page summaries, VNUM identifiers, and source links from the official USGS Volcano Hazards Program notification feed.

Use it for scheduled monitoring, risk dashboards, aviation operations, emergency management, insurance research, geospatial enrichment, and scientific news tracking.

### What does USGS Volcano Activity Notifications Scraper do?

USGS Volcano Activity Notifications Scraper reads the public HANS page at `https://volcanoes.usgs.gov/hans-public/`.

It finds recent volcano notices and VONA records.

It follows each linked detail page when requested.

It saves each notification as a dataset item.

It keeps the source URL so you can audit every record.

It includes both human-readable fields and machine-friendly fields.

It does not require a login, API key, browser session, or private USGS account.

### Who is it for?

Aviation operations teams can watch aviation color codes for ORANGE or RED changes.

Emergency managers can schedule repeated checks for new volcano activity notices.

Insurance and infrastructure risk analysts can enrich exposure models with official volcano alerts.

Geospatial data teams can join USGS VNUMs and volcano names into maps and dashboards.

Researchers can archive official USGS notification text for longitudinal studies.

News and OSINT teams can monitor volcano status changes without manually checking the page.

Developers can feed structured volcano alerts into Slack, webhooks, databases, or BI tools.

### Why use this actor?

The USGS HANS page is public but optimized for people, not automation.

This actor turns that HTML into typed records.

It extracts detail text that is useful for downstream keyword search.

It deduplicates notices repeated in multiple page sections.

It adds filters so you can monitor only the observatories, volcanoes, alert levels, or aviation colors you care about.

It is HTTP-first, so runs are lightweight and fast.

### Data source

The source is the USGS Volcano Hazards Program HANS public notification page.

Default source URL:

`https://volcanoes.usgs.gov/hans-public/`

The actor also follows linked `/notice/` and `/vona/` pages on the same host.

The output reflects what USGS publishes at run time.

If USGS changes or removes a notice, future runs will reflect the current page.

### Output data

Each dataset item represents one USGS notice URL.

The actor saves listing metadata and, when enabled, detail-page data.

Important output fields include:

| Field | Description |
| --- | --- |
| `noticeId` | Stable ID parsed from the USGS notice URL |
| `noticeUrl` | Direct USGS notice or VONA URL |
| `sourceUrl` | Listing page used for discovery |
| `title` | Notice title from the listing |
| `noticeType` | VONA or Volcano Activity Notification |
| `section` | Listing section such as Last 24 Hours or Recent Notices |
| `observatory` | USGS observatory section |
| `sentTimeUtc` | Sent timestamp in UTC when available |
| `sentUnixTime` | Source UNIX timestamp when USGS provides it |
| `volcanoName` | Primary volcano name |
| `volcanoNames` | All volcano names detected for the notice |
| `vnums` | USGS volcano numbers from detail pages |
| `alertLevel` | Current volcano alert level |
| `aviationColorCode` | Aviation color code |
| `volcanoes` | Nested volcano details with summaries and monitoring links |
| `summary` | First parsed volcano summary |
| `bodyText` | Cleaned detail-page body text |
| `scrapedAt` | Extraction timestamp |

### Example output

```json
{
  "noticeId": "DOI-USGS-HVO-2026-07-09T18:04:49+00:00",
  "noticeUrl": "https://volcanoes.usgs.gov/hans-public/notice/DOI-USGS-HVO-2026-07-09T18:04:49+00:00",
  "title": "Kilauea Daily Update",
  "noticeType": "Volcano Activity Notification",
  "observatory": "Hawaiian Volcano Observatory",
  "sentTimeUtc": "2026-07-09T18:35:33.000Z",
  "volcanoName": "Kilauea",
  "volcanoNames": ["KILAUEA"],
  "alertLevel": "WATCH",
  "aviationColorCode": "ORANGE",
  "summary": "Summary text from the USGS notice",
  "scrapedAt": "2026-07-10T00:00:00.000Z"
}
````

### How much does it cost to scrape USGS volcano notifications?

This actor uses pay-per-event pricing.

There is a $0.005 start fee per run.

There is a per-notification charge for each dataset item saved.

The BRONZE per-notification price is $0.000055673, with lower tier prices for larger plans.

The default input is intentionally limited to the current public listing so you can test cheaply.

For full production monitoring, schedule the actor and set `maxItems` to the number of recent notices you need.

Live prices are shown on the Apify Store page before you start a run.

### Input options

`maxItems` controls how many notice records are saved.

`includeDetails` controls whether the actor follows notice and VONA detail links.

`startUrls` lets advanced users override the default HANS listing URL.

`observatories` filters by observatory names or abbreviations.

`volcanoNames` filters by volcano names such as Kilauea or Great Sitkin.

`alertLevels` filters by alert levels such as NORMAL, ADVISORY, WATCH, or WARNING.

`aviationColorCodes` filters by GREEN, YELLOW, ORANGE, or RED.

`startDate` keeps notices sent after a date or timestamp.

`endDate` keeps notices sent before a date or timestamp.

`includeDuplicates` keeps repeated listing rows when USGS displays the same notice in multiple sections.

### Example input

```json
{
  "maxItems": 100,
  "includeDetails": true,
  "aviationColorCodes": ["ORANGE", "RED"],
  "includeDuplicates": false
}
```

### How to run it

Open the actor on Apify.

Click **Try for free**.

Keep the default input for a full recent-notice scrape.

Add filters if you only need one volcano, observatory, alert level, or aviation color.

Start the run.

Download the dataset as JSON, CSV, Excel, XML, or RSS.

Connect the dataset to your workflow through the Apify API, webhooks, integrations, or MCP.

### Monitoring workflows

Schedule the actor hourly or daily for recurring volcano alert monitoring.

Filter for ORANGE and RED aviation color codes for aviation safety dashboards.

Filter for WATCH and WARNING alert levels for emergency-management escalation.

Filter by observatory when your team only covers Alaska, Hawaii, Yellowstone, Cascades, California, or Northern Mariana Islands notices.

Send new dataset items to Slack, email, or a webhook.

Store historical runs in your database for trend analysis.

### Tips for best results

Keep `includeDuplicates` disabled unless you need to mirror the listing page exactly.

Use `includeDetails` when you need VNUMs, summaries, and full notice text.

Disable `includeDetails` for very fast link-only monitoring.

Use date filters when backfilling a known time window from a listing page.

Use volcano name filters for focused scheduled checks.

Use aviation color filters for operational alerting.

### Integrations

Send output to Google Sheets for analyst review.

Send ORANGE or RED notices to Slack through an Apify webhook.

Store notice text in a database for search and historical comparison.

Join VNUM values with geospatial volcano layers.

Trigger incident-management workflows when alert levels match your escalation rules.

Use Apify integrations to export JSON, CSV, Excel, or RSS.

### 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/usgs-volcano-activity-notifications-scraper').call({
  maxItems: 100,
  includeDetails: true,
  aviationColorCodes: ['ORANGE', 'RED']
});
console.log(`Dataset: https://api.apify.com/v2/datasets/${run.defaultDatasetId}/items`);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/usgs-volcano-activity-notifications-scraper').call(run_input={
    'maxItems': 100,
    'includeDetails': True,
    'aviationColorCodes': ['ORANGE', 'RED'],
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~usgs-volcano-activity-notifications-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"includeDetails":true,"aviationColorCodes":["ORANGE","RED"]}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or another MCP-compatible client through Apify MCP.

MCP server URL:

`https://mcp.apify.com/?tools=automation-lab/usgs-volcano-activity-notifications-scraper`

Claude Code setup:

```bash
claude mcp add apify-usgs-volcano-notifications https://mcp.apify.com/?tools=automation-lab/usgs-volcano-activity-notifications-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-usgs-volcano-notifications": {
      "url": "https://mcp.apify.com/?tools=automation-lab/usgs-volcano-activity-notifications-scraper"
    }
  }
}
```

Example prompts:

- "Run the USGS volcano notifications scraper and show any ORANGE aviation color notices."
- "Monitor Kilauea notices and summarize the latest USGS alert level."
- "Fetch recent USGS HANS volcano notices and return a CSV-ready table."

### Related scrapers

Explore related Automation Lab actors on Apify:

- `https://apify.com/automation-lab/website-contact-finder`
- `https://apify.com/automation-lab/bulk-url-status-checker`
- `https://apify.com/automation-lab/google-news-scraper`

Use this actor when the required source is USGS HANS volcano notifications.

Use broader disaster or news scrapers when you need multi-source incident coverage.

### Legality and responsible use

This actor extracts public USGS web pages.

Respect the source website and use reasonable schedules.

Do not overload public services.

Review USGS terms, your compliance obligations, and any downstream use requirements before production use.

The actor does not bypass authentication, paywalls, CAPTCHA, or access controls.

### Troubleshooting

If you get fewer items than expected, increase `maxItems` and remove filters.

If `alertLevel` or `aviationColorCode` is empty, the listing or detail page may not include that value for the specific notice.

If you only need notice URLs and timestamps, set `includeDetails` to false.

If a volcano name filter returns zero records, try a broader spelling or run without the filter to inspect current USGS titles.

If a scheduled run returns no new high-severity alerts, check the full dataset to confirm that only lower alert levels were present.

### FAQ

#### Does this actor use the official USGS source?

Yes. It reads the public USGS HANS notification page and linked USGS notice pages.

#### Does it require a browser?

No. The data is available in the initial HTML, so the actor uses fast HTTP extraction.

#### Can I monitor one volcano?

Yes. Use `volcanoNames`, for example `["Kilauea"]` or `["Great Sitkin"]`.

#### Can I monitor aviation color codes?

Yes. Use `aviationColorCodes`, for example `["ORANGE", "RED"]`.

#### Can I schedule it?

Yes. Use Apify schedules to run it on an hourly, daily, or custom cadence.

#### Does it output CSV?

Yes. Apify datasets can be downloaded as CSV, JSON, Excel, XML, RSS, or accessed through the API.

### Support

If the USGS page layout changes and extraction quality drops, open an issue on Apify with the run ID and expected records.

Include the input used, the run URL, and the notice URL you expected to see.

### Changelog

See `.actor/CHANGELOG.md` for release notes.

# Actor input Schema

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

Maximum number of unique USGS volcano notification rows to save. Use 100+ for the full current public listing.

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

When enabled, follows each USGS notice/VONA link and extracts volcano names, VNUMs, summaries, alert levels, color codes, and body text.

## `startUrls` (type: `array`):

Optional USGS HANS listing page override. Leave empty to use https://volcanoes.usgs.gov/hans-public/.

## `observatories` (type: `array`):

Optional case-insensitive observatory filters, e.g. HVO, AVO, Alaska Volcano Observatory, Hawaiian Volcano Observatory.

## `volcanoNames` (type: `array`):

Optional case-insensitive volcano name filters, e.g. Kilauea, Great Sitkin, Shishaldin.

## `alertLevels` (type: `array`):

Optional alert level filters. Common values are NORMAL, ADVISORY, WATCH, and WARNING.

## `aviationColorCodes` (type: `array`):

Optional aviation color code filters. Common values are GREEN, YELLOW, ORANGE, and RED.

## `startDate` (type: `string`):

Optional earliest sent timestamp/date, e.g. 2026-07-01 or 2026-07-01T00:00:00Z.

## `endDate` (type: `string`):

Optional latest sent timestamp/date, e.g. 2026-07-31 or 2026-07-31T23:59:59Z.

## `includeDuplicates` (type: `boolean`):

USGS may repeat the same notice in Last 24 Hours and Recent Notices. Keep disabled to save each notice URL once.

## Actor input object example

```json
{
  "maxItems": 20,
  "includeDetails": true,
  "startUrls": [
    {
      "url": "https://volcanoes.usgs.gov/hans-public/"
    }
  ],
  "observatories": [],
  "volcanoNames": [],
  "alertLevels": [],
  "aviationColorCodes": [],
  "includeDuplicates": false
}
```

# Actor output Schema

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

No description

## `details` (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 = {
    "maxItems": 20,
    "includeDetails": true,
    "startUrls": [
        {
            "url": "https://volcanoes.usgs.gov/hans-public/"
        }
    ],
    "observatories": [],
    "volcanoNames": [],
    "alertLevels": [],
    "aviationColorCodes": [],
    "includeDuplicates": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/usgs-volcano-activity-notifications-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 = {
    "maxItems": 20,
    "includeDetails": True,
    "startUrls": [{ "url": "https://volcanoes.usgs.gov/hans-public/" }],
    "observatories": [],
    "volcanoNames": [],
    "alertLevels": [],
    "aviationColorCodes": [],
    "includeDuplicates": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/usgs-volcano-activity-notifications-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 '{
  "maxItems": 20,
  "includeDetails": true,
  "startUrls": [
    {
      "url": "https://volcanoes.usgs.gov/hans-public/"
    }
  ],
  "observatories": [],
  "volcanoNames": [],
  "alertLevels": [],
  "aviationColorCodes": [],
  "includeDuplicates": false
}' |
apify call automation-lab/usgs-volcano-activity-notifications-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Volcano Activity Notifications Scraper",
        "description": "Scrape official USGS HANS volcano notices, alert levels, aviation color codes, observatories, timestamps, VNUMs, summaries, and URLs.",
        "version": "0.1",
        "x-build-id": "7GR30NUnWgRbZOGhQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~usgs-volcano-activity-notifications-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-usgs-volcano-activity-notifications-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~usgs-volcano-activity-notifications-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-usgs-volcano-activity-notifications-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~usgs-volcano-activity-notifications-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-usgs-volcano-activity-notifications-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": {
                    "maxItems": {
                        "title": "Maximum notices",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique USGS volcano notification rows to save. Use 100+ for the full current public listing.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch notice detail pages",
                        "type": "boolean",
                        "description": "When enabled, follows each USGS notice/VONA link and extracts volcano names, VNUMs, summaries, alert levels, color codes, and body text.",
                        "default": true
                    },
                    "startUrls": {
                        "title": "USGS HANS listing URLs",
                        "type": "array",
                        "description": "Optional USGS HANS listing page override. Leave empty to use https://volcanoes.usgs.gov/hans-public/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "observatories": {
                        "title": "Observatories",
                        "type": "array",
                        "description": "Optional case-insensitive observatory filters, e.g. HVO, AVO, Alaska Volcano Observatory, Hawaiian Volcano Observatory.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "volcanoNames": {
                        "title": "Volcano names",
                        "type": "array",
                        "description": "Optional case-insensitive volcano name filters, e.g. Kilauea, Great Sitkin, Shishaldin.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "alertLevels": {
                        "title": "Volcano alert levels",
                        "type": "array",
                        "description": "Optional alert level filters. Common values are NORMAL, ADVISORY, WATCH, and WARNING.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "aviationColorCodes": {
                        "title": "Aviation color codes",
                        "type": "array",
                        "description": "Optional aviation color code filters. Common values are GREEN, YELLOW, ORANGE, and RED.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Sent after",
                        "type": "string",
                        "description": "Optional earliest sent timestamp/date, e.g. 2026-07-01 or 2026-07-01T00:00:00Z."
                    },
                    "endDate": {
                        "title": "Sent before",
                        "type": "string",
                        "description": "Optional latest sent timestamp/date, e.g. 2026-07-31 or 2026-07-31T23:59:59Z."
                    },
                    "includeDuplicates": {
                        "title": "Include duplicate listing rows",
                        "type": "boolean",
                        "description": "USGS may repeat the same notice in Last 24 Hours and Recent Notices. Keep disabled to save each notice URL once.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
