# US Drought Monitor Scraper (`parseforge/us-drought-monitor-scraper`) Actor

Pull weekly US Drought Monitor severity statistics by area percent for the nation, any state, or a county. Returns map date, None and D0 to D4 coverage, valid start and end dates. Export to CSV, Excel, JSON, or XML for climate research.

- **URL**: https://apify.com/parseforge/us-drought-monitor-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.44 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🌵 US Drought Monitor Scraper

> 🚀 **Export weekly US Drought Monitor statistics in one run.** Pull the national series, any state, or any county straight from the University of Nebraska Lincoln data service.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 15 fields** per record · national, state, and county coverage · one record per weekly map

Turn the US Drought Monitor into clean, structured weekly records you can drop into a spreadsheet, a climate dashboard, or a research notebook. Pick an area of interest and a date range, and get one row per published map week with the share of land in each drought category.

Coverage matches what the US Drought Monitor publishes through the UNL data service: the country-wide CONUS and total series, every state by its FIPS code, and any county by its 5 digit FIPS code. Each week reports the percent of the area in None, D0 (abnormally dry), D1 (moderate), D2 (severe), D3 (extreme), and D4 (exceptional) drought.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Climate and hydrology researchers | Build long weekly drought time series |
| Agriculture and commodity analysts | Watch crop region dryness trends |
| Water utilities and policy teams | Track conditions for planning and reporting |
| Journalists and data storytellers | Chart how drought shifts week to week |

### 📋 What the US Drought Monitor Scraper does

This Actor calls the public US Drought Monitor area percent statistics service and returns one clean record per weekly map for the area you choose:

- **United States (national)** — the CONUS and total series with None and D0 to D4 coverage.
- **State** — pick a state and get its weekly drought breakdown.
- **County** — supply a 5 digit county FIPS code for county level detail with county and state labels.

You choose the date range, the statistics type, and how many records come back, and every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `aoi` | select | Area of interest. `us` for the national series, or a state from the list. Defaults to `us`. |
| `countyFips` | string | Optional 5 digit county FIPS code, for example `06037`. When set, it overrides the area of interest and returns county level rows. |
| `startdate` | string | First date of the range, for example `1/1/2024` or `2024-01-01`. |
| `enddate` | string | Last date of the range, for example `2/1/2024`. |
| `statisticsType` | select | `Traditional (cumulative)` or `Categorical (non overlapping)`. Defaults to traditional. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — national series for early 2024**
```json
{
    "aoi": "us",
    "startdate": "1/1/2024",
    "enddate": "3/1/2024",
    "statisticsType": "1",
    "maxItems": 20
}
````

**Example 2 — a single county**

```json
{
    "countyFips": "06037",
    "startdate": "1/1/2024",
    "enddate": "6/1/2024",
    "statisticsType": "1",
    "maxItems": 25
}
```

> ⚠️ **Good to Know:** The US Drought Monitor publishes one map per week, so a one month range returns roughly four or five rows. For the national series the area name comes back as both `CONUS` and `Total`, so a single national run mixes those two series. State rows are selected by state FIPS code, not by abbreviation.

### 📊 Output

Each weekly record looks like this:

| Field | Description |
|---|---|
| 📍 `areaOfInterest` | Area label (CONUS, Total, a state abbreviation, or county and state) |
| 🆔 `fips` | County FIPS code, present for county runs |
| 🏛 `county` | County name, present for county runs |
| 🗺 `state` | State abbreviation, present for state and county runs |
| 📅 `mapDate` | Date of the weekly map |
| 🟢 `none` | Percent of area in no drought |
| 🟡 `d0` | Percent in D0 abnormally dry |
| 🟠 `d1` | Percent in D1 moderate drought |
| 🔴 `d2` | Percent in D2 severe drought |
| 🟤 `d3` | Percent in D3 extreme drought |
| ⚫ `d4` | Percent in D4 exceptional drought |
| ▶ `validStart` | Start of the week the map is valid for |
| ⏹ `validEnd` | End of the week the map is valid for |
| 🔢 `statisticFormatID` | 1 for traditional, 2 for categorical |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — national (CONUS)**

```json
{
    "areaOfInterest": "CONUS",
    "fips": null,
    "county": null,
    "state": null,
    "mapDate": "2024-02-27T00:00:00",
    "none": 53.16,
    "d0": 46.84,
    "d1": 21.59,
    "d2": 7.79,
    "d3": 1.49,
    "d4": 0.14,
    "validStart": "2024-02-27T00:00:00",
    "validEnd": "2024-03-04T23:59:59",
    "statisticFormatID": 1,
    "scrapedAt": "2026-06-08T22:20:56.134Z",
    "error": null
}
```

**Real sample — state (Texas)**

```json
{
    "areaOfInterest": "TX",
    "fips": null,
    "county": null,
    "state": "TX",
    "mapDate": "2024-01-30T00:00:00",
    "none": 56.93,
    "d0": 43.07,
    "d1": 22.75,
    "d2": 9.68,
    "d3": 1.92,
    "d4": 0.00,
    "validStart": "2024-01-30T00:00:00",
    "validEnd": "2024-02-05T23:59:59",
    "statisticFormatID": 1,
    "scrapedAt": "2026-06-08T22:19:04.451Z",
    "error": null
}
```

**Real sample — county (Los Angeles County, CA)**

```json
{
    "areaOfInterest": "Los Angeles County, CA",
    "fips": "06037",
    "county": "Los Angeles County",
    "state": "CA",
    "mapDate": "2024-01-30T00:00:00",
    "none": 100.00,
    "d0": 0.00,
    "d1": 0.00,
    "d2": 0.00,
    "d3": 0.00,
    "d4": 0.00,
    "validStart": "2024-01-30T00:00:00",
    "validEnd": "2024-02-05T23:59:59",
    "statisticFormatID": 1,
    "scrapedAt": "2026-06-08T22:18:52.492Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per weekly map, ready for a time series.
- National, state, and county coverage share a single consistent shape.
- Both traditional cumulative and categorical non overlapping percentages are supported.
- No account, no key, and no login required at the source.
- Stable field names that map cleanly onto a database schema.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Coverage | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | National, state, county | None on your side |
| Hand-copying from the website | Hours | Inconsistent | Limited | Constant |
| Writing your own API client | Days | Depends | You build it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the US Drought Monitor Scraper.
3. Choose an `aoi`, or enter a `countyFips` for county level data.
4. Set `startdate`, `enddate`, the `statisticsType`, and `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Agriculture and commodities

| Goal | How this helps |
|---|---|
| Watch dryness in growing regions | Pull weekly county or state drought levels |
| Time planting and irrigation calls | Track how D0 to D4 shares move week to week |

#### Water and utilities

| Goal | How this helps |
|---|---|
| Inform conservation decisions | Follow severe and extreme drought coverage |
| Support planning reports | Snapshot the series for a region and period |

#### Insurance and finance

| Goal | How this helps |
|---|---|
| Assess drought exposure | Map county FIPS coverage to portfolios |
| Backtest weather risk models | Build long weekly drought histories |

#### Media and research

| Goal | How this helps |
|---|---|
| Chart drought trends | Feed weekly percentages into a visualization |
| Compare regions | Run multiple states and align by map date |

### 🔌 Automating US Drought Monitor Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** assemble multi year weekly drought series for analysis.
- **Personal:** keep an eye on conditions in your own county.
- **Non-profit:** power a community water or conservation resource.
- **Experimentation:** prototype a climate data app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize drought trends, compare states, or flag the weeks with the most extreme coverage.

### ❓ Frequently Asked Questions

**Do I need an account or key?**
No. The Actor reads the public US Drought Monitor data service, which needs no login or key.

**What area can I pull?**
The national series, any state from the list, or any county by its 5 digit FIPS code.

**How do I get a single state?**
Choose the state from the `aoi` dropdown. States are selected internally by their FIPS code.

**How do I get a county?**
Enter the 5 digit county FIPS in `countyFips`, for example `06037` for Los Angeles County. It overrides the area of interest.

**What date format should I use?**
Both `1/1/2024` and `2024-01-01` work for `startdate` and `enddate`.

**Why do I see both CONUS and Total for the national run?**
The source publishes the national series under two labels, CONUS and Total. Filter by `areaOfInterest` to keep one.

**What is the difference between traditional and categorical?**
Traditional reports each level cumulatively, so D0 includes D1 to D4. Categorical reports each level as its own non overlapping slice.

**What do D0 to D4 mean?**
D0 is abnormally dry, D1 moderate, D2 severe, D3 extreme, and D4 exceptional drought.

**How many records will I get?**
One per weekly map in your date range, so about four or five per month, up to your `maxItems`.

**How fresh is the data?**
Each run pulls live from the US Drought Monitor service, so it reflects what they have published for your range.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- More reference and open data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the US Drought Monitor, the University of Nebraska Lincoln, USDA, or NOAA. Only publicly available data is collected.

# Actor input Schema

## `aoi` (type: `string`):

Region to pull weekly drought statistics for. Choose 'United States (national)' for the country-wide series, or pick a state. For a specific county, leave this on a state and fill in the County FIPS field below.

## `countyFips` (type: `string`):

Optional. A 5 digit county FIPS code, for example '06037' for Los Angeles County or '48201' for Harris County. When set, this overrides the Area of interest and returns county level statistics.

## `startdate` (type: `string`):

First date of the range, for example '1/1/2024' or '2024-01-01'. The US Drought Monitor publishes one map per week, so each week inside the range becomes one record.

## `enddate` (type: `string`):

Last date of the range, for example '2/1/2024' or '2024-02-01'.

## `statisticsType` (type: `string`):

Traditional reports each drought level as cumulative coverage (D0 includes D1 to D4). Categorical reports each level as its own non overlapping slice.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "aoi": "us",
  "startdate": "1/1/2024",
  "enddate": "2/1/2024",
  "statisticsType": "1",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/us-drought-monitor-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": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/us-drought-monitor-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": 10
}' |
apify call parseforge/us-drought-monitor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Drought Monitor Scraper",
        "description": "Pull weekly US Drought Monitor severity statistics by area percent for the nation, any state, or a county. Returns map date, None and D0 to D4 coverage, valid start and end dates. Export to CSV, Excel, JSON, or XML for climate research.",
        "version": "0.1",
        "x-build-id": "Qn5A8rajCEUevPfhZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~us-drought-monitor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-us-drought-monitor-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/parseforge~us-drought-monitor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-us-drought-monitor-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/parseforge~us-drought-monitor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-us-drought-monitor-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": {
                    "aoi": {
                        "title": "Area of interest",
                        "enum": [
                            "us",
                            "01",
                            "02",
                            "04",
                            "05",
                            "06",
                            "08",
                            "09",
                            "10",
                            "11",
                            "12",
                            "13",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "21",
                            "22",
                            "23",
                            "24",
                            "25",
                            "26",
                            "27",
                            "28",
                            "29",
                            "30",
                            "31",
                            "32",
                            "33",
                            "34",
                            "35",
                            "36",
                            "37",
                            "38",
                            "39",
                            "40",
                            "41",
                            "42",
                            "44",
                            "45",
                            "46",
                            "47",
                            "48",
                            "49",
                            "50",
                            "51",
                            "53",
                            "54",
                            "55",
                            "56",
                            "72"
                        ],
                        "type": "string",
                        "description": "Region to pull weekly drought statistics for. Choose 'United States (national)' for the country-wide series, or pick a state. For a specific county, leave this on a state and fill in the County FIPS field below.",
                        "default": "us"
                    },
                    "countyFips": {
                        "title": "County FIPS (optional)",
                        "type": "string",
                        "description": "Optional. A 5 digit county FIPS code, for example '06037' for Los Angeles County or '48201' for Harris County. When set, this overrides the Area of interest and returns county level statistics."
                    },
                    "startdate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "First date of the range, for example '1/1/2024' or '2024-01-01'. The US Drought Monitor publishes one map per week, so each week inside the range becomes one record.",
                        "default": "1/1/2024"
                    },
                    "enddate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Last date of the range, for example '2/1/2024' or '2024-02-01'.",
                        "default": "2/1/2024"
                    },
                    "statisticsType": {
                        "title": "Statistics type",
                        "enum": [
                            "1",
                            "2"
                        ],
                        "type": "string",
                        "description": "Traditional reports each drought level as cumulative coverage (D0 includes D1 to D4). Categorical reports each level as its own non overlapping slice.",
                        "default": "1"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
