# NOAA CoastWatch ERDDAP Ocean Data Scraper (`parseforge/noaa-coastwatch-erddap-scraper`) Actor

Pull ocean buoy and station readings from NOAA CoastWatch ERDDAP, including station ID, latitude, longitude, timestamp, water temperature, air temperature, and wind speed. Browse the full dataset catalog too. Useful for marine forecasting, climate research, and coastal monitoring.

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

## Pricing

from $3.00 / 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)

## 🌊 NOAA CoastWatch ERDDAP Ocean Data Scraper

> 🚀 **Pull ocean buoy and station readings in seconds.** Get station ID, latitude, longitude, timestamp, water temperature, air temperature, and wind speed from NOAA CoastWatch ERDDAP, or browse the full dataset catalog.

> 🕒 **Last updated:** 2026-06-08 · **📊 Two modes** (station records + dataset catalog) · live NDBC buoy feed · global coastal coverage

Turn the NOAA CoastWatch ERDDAP data server into clean, structured records you can drop into a marine forecast, a climate study, a coastal-monitoring dashboard, or a research notebook. Choose **Station records** to pull oceanographic observations from a tabledap dataset, or **Dataset catalog** to list every dataset available on the server with its coverage metadata.

Coverage spans NOAA's CoastWatch ERDDAP holdings. The default station dataset is `cwwcNDBCMet`, the NDBC Standard Meteorological Buoy Data feed, with thousands of buoys and coastal stations worldwide reporting water and air temperature, wind, and more. When no time window is given, the Actor auto-selects a recent one-hour window anchored to the dataset's latest available data, so a default run always returns fresh rows.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Marine forecasters and meteorologists | Pull live buoy water and air temperature, wind |
| Climate and ocean researchers | Build time series from station observations |
| Coastal and port operators | Monitor conditions at specific stations |
| Data engineers and app developers | Catalog ERDDAP datasets and feed pipelines |

### 📋 What the NOAA CoastWatch ERDDAP Scraper does

This Actor calls the public NOAA CoastWatch ERDDAP server and runs in one of two modes:

- **Station records (`data`)** — pulls observations from a tabledap dataset. `station`, `longitude`, `latitude`, and `time` are always included; you choose the extra measurement variables (water temp `wtmp`, air temp `atmp`, wind speed `wspd`, and any others the dataset offers).
- **Dataset catalog (`catalog`)** — lists every dataset on the server with its title, institution, time and spatial coverage, and tabledap/griddap URLs.

Every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | `data` (Station records) or `catalog` (Dataset catalog). Defaults to `data`. |
| `datasetId` | string | The tabledap dataset ID to pull from in `data` mode. Defaults to `cwwcNDBCMet`. |
| `variables` | array | Measurement variables to return per record, e.g. `wtmp`, `atmp`, `wspd`. `station`, `longitude`, `latitude`, and `time` are always included. Defaults to `wtmp, atmp, wspd`. |
| `startTime` | string | Lower bound of the time window in ISO 8601 UTC, e.g. `2026-05-14T21:00:00Z`. Leave empty to auto-select a recent window. |
| `endTime` | string | Upper bound of the time window in ISO 8601 UTC. Leave empty to use the dataset's latest timestamp. |
| `stationFilter` | string | Optional exact station ID, e.g. `41002`, to restrict to one station. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — latest readings for a single buoy**
```json
{
    "mode": "data",
    "datasetId": "cwwcNDBCMet",
    "variables": ["wtmp", "atmp", "wspd"],
    "stationFilter": "41002",
    "maxItems": 10
}
````

**Example 2 — browse the dataset catalog**

```json
{
    "mode": "catalog",
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** in `data` mode, leaving `startTime` and `endTime` empty makes the Actor read the dataset's latest available timestamp and pull a one-hour window ending there, so you always get fresh rows. Provide your own window to pull a historical range. A variable you request that the dataset does not carry comes back null.

### 📊 Output

#### Station records (`data` mode)

| Field | Description |
|---|---|
| 🛟 `station` | Station or buoy ID |
| 🗂 `datasetId` | ERDDAP dataset the row came from |
| 📍 `latitude` | Station latitude |
| 📍 `longitude` | Station longitude |
| 🕒 `time` | Observation timestamp (UTC) |
| 🌊 `wtmp` | Water temperature (when requested) |
| 🌡 `atmp` | Air temperature (when requested) |
| 💨 `wspd` | Wind speed (when requested) |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

Requested variables beyond the four anchors are added as their own fields using the dataset's own variable names.

**Real sample — station record**

```json
{
    "station": "41002",
    "datasetId": "cwwcNDBCMet",
    "latitude": 31.759,
    "longitude": -74.84,
    "time": "2026-06-08T16:00:00Z",
    "wtmp": 26.1,
    "atmp": 25.4,
    "wspd": 6.0,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

#### Dataset catalog (`catalog` mode)

| Field | Description |
|---|---|
| 📌 `title` | Dataset title |
| 🗂 `datasetId` | ERDDAP dataset ID |
| 🏛 `institution` | Institution that provides it |
| 🕘 `minTime` | Earliest time coverage |
| 🕛 `maxTime` | Latest time coverage |
| 🧭 `minLongitude` | West edge of coverage |
| 🧭 `maxLongitude` | East edge of coverage |
| 🧭 `minLatitude` | South edge of coverage |
| 🧭 `maxLatitude` | North edge of coverage |
| 🔗 `tabledapUrl` | tabledap base URL |
| 🔗 `griddapUrl` | griddap base URL |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — catalog record**

```json
{
    "title": "NDBC Standard Meteorological Buoy Data, 1970-present",
    "datasetId": "cwwcNDBCMet",
    "institution": "NOAA NDBC, CoastWatch WCN",
    "minTime": "1970-02-26T20:00:00Z",
    "maxTime": "2026-06-08T16:00:00Z",
    "minLongitude": -177.75,
    "maxLongitude": 179.999,
    "minLatitude": -55.0,
    "maxLatitude": 71.823,
    "tabledapUrl": "https://coastwatch.pfeg.noaa.gov/erddap/tabledap/cwwcNDBCMet",
    "griddapUrl": null,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Two modes in one Actor: pull station observations or browse the catalog.
- Smart default window anchors to the latest available data, so runs always return fresh rows.
- Pick exactly the measurement variables you need.
- Filter to a single station by ID.
- No account, no API key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Catalog browsing | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Built in | None on your side |
| Hand-building ERDDAP URLs | Tedious | Manual | Manual | Constant |
| Writing your own 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 NOAA CoastWatch ERDDAP Ocean Data Scraper.
3. Choose a `mode` (`data` or `catalog`).
4. For `data`, set `datasetId`, `variables`, an optional time window, and an optional `stationFilter`.
5. Set `maxItems`, click **Start**, and grab your results when the run finishes.

### 💼 Business use cases

#### Marine forecasting

| Goal | How this helps |
|---|---|
| Brief on sea conditions | Pull live water temp, air temp, and wind |
| Watch a specific buoy | Use `stationFilter` for one station |

#### Climate and ocean research

| Goal | How this helps |
|---|---|
| Build a time series | Set a historical `startTime`/`endTime` window |
| Survey available data | Use `catalog` mode to map coverage |

#### Coastal operations

| Goal | How this helps |
|---|---|
| Monitor a port approach | Track the nearest station's readings |
| Spot anomalies | Compare current readings to recent windows |

#### Data engineering

| Goal | How this helps |
|---|---|
| Catalog ERDDAP datasets | List every dataset with coverage and URLs |
| Feed a pipeline | Schedule station pulls into your warehouse |

### 🔌 Automating NOAA CoastWatch ERDDAP 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 the latest buoy readings to a channel.
- **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 buoy time series for a study area.
- **Personal:** check sea temperature before a dive or a sail.
- **Non-profit:** power a community coastal-conditions board.
- **Experimentation:** prototype an ocean data app without an ERDDAP client.

### 🤖 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 chart water temperature over time, find the windiest stations, or map which datasets cover your region.

### ❓ Frequently Asked Questions

**Do I need a NOAA account or API key?**
No. The Actor reads the public NOAA CoastWatch ERDDAP server, which needs no login.

**What dataset does it use by default?**
`cwwcNDBCMet`, the NDBC Standard Meteorological Buoy Data feed. You can point `datasetId` at any tabledap dataset on the server.

**Which variables can I request?**
Any variables the dataset offers. The defaults are `wtmp`, `atmp`, and `wspd`. `station`, `longitude`, `latitude`, and `time` are always included.

**What if I leave the time window empty?**
The Actor reads the dataset's latest timestamp and pulls a recent one-hour window ending there, so you always get fresh data.

**Can I get historical data?**
Yes. Set `startTime` and `endTime` in ISO 8601 UTC to pull any past window.

**How do I get only one station?**
Set `stationFilter` to the exact station ID, for example `41002`.

**What is catalog mode for?**
It lists every dataset on the server with its title, institution, time and spatial coverage, and access URLs, so you can discover what is available.

**Why is a variable null on some rows?**
Not every station reports every variable, and not every dataset carries every variable you request. Missing values come back null.

**How fresh is the data?**
Each run reads live from ERDDAP, so station records reflect the latest published observations.

**Can I schedule this?**
Yes. Use Apify Schedules to pull station readings on any cadence.

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

- [USNO Astronomical Almanac Scraper](https://apify.com/parseforge)
- [NASA JPL Horizons Ephemeris Scraper](https://apify.com/parseforge)
- More science and reference 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 NOAA or CoastWatch. Only publicly available data is collected.

# Actor input Schema

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

What to fetch. 'Station records' pulls oceanographic observations from a tabledap dataset. 'Dataset catalog' lists every dataset available in this ERDDAP with its coverage metadata.

## `datasetId` (type: `string`):

The ERDDAP tabledap dataset ID to pull records from when Mode is 'Station records'. Defaults to cwwcNDBCMet, the NDBC Standard Meteorological Buoy Data feed.

## `variables` (type: `array`):

Measurement variables to return per record, for example wtmp (water temp), atmp (air temp), wspd (wind speed). station, longitude, latitude, and time are always included. Leave empty to use wtmp, atmp, wspd.

## `startTime` (type: `string`):

Lower bound of the time window in ISO 8601 UTC, for example 2026-05-14T21:00:00Z. Leave empty to auto-select a recent one hour window from the dataset's latest available data.

## `endTime` (type: `string`):

Upper bound of the time window in ISO 8601 UTC, for example 2026-05-14T22:00:00Z. Leave empty to auto-select the dataset's latest available timestamp.

## `stationFilter` (type: `string`):

Optional exact station ID to restrict results to a single station, for example 41002. Leave empty to include all stations in the time window.

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

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

## Actor input object example

```json
{
  "mode": "data",
  "datasetId": "cwwcNDBCMet",
  "variables": [
    "wtmp",
    "atmp",
    "wspd"
  ],
  "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 = {
    "variables": [
        "wtmp",
        "atmp",
        "wspd"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/noaa-coastwatch-erddap-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 = {
    "variables": [
        "wtmp",
        "atmp",
        "wspd",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/noaa-coastwatch-erddap-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 '{
  "variables": [
    "wtmp",
    "atmp",
    "wspd"
  ],
  "maxItems": 10
}' |
apify call parseforge/noaa-coastwatch-erddap-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA CoastWatch ERDDAP Ocean Data Scraper",
        "description": "Pull ocean buoy and station readings from NOAA CoastWatch ERDDAP, including station ID, latitude, longitude, timestamp, water temperature, air temperature, and wind speed. Browse the full dataset catalog too. Useful for marine forecasting, climate research, and coastal monitoring.",
        "version": "0.1",
        "x-build-id": "xCHMdoo6B9b6BCyyR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~noaa-coastwatch-erddap-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-noaa-coastwatch-erddap-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~noaa-coastwatch-erddap-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-noaa-coastwatch-erddap-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~noaa-coastwatch-erddap-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-noaa-coastwatch-erddap-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "data",
                            "catalog"
                        ],
                        "type": "string",
                        "description": "What to fetch. 'Station records' pulls oceanographic observations from a tabledap dataset. 'Dataset catalog' lists every dataset available in this ERDDAP with its coverage metadata.",
                        "default": "data"
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "The ERDDAP tabledap dataset ID to pull records from when Mode is 'Station records'. Defaults to cwwcNDBCMet, the NDBC Standard Meteorological Buoy Data feed.",
                        "default": "cwwcNDBCMet"
                    },
                    "variables": {
                        "title": "Variables",
                        "type": "array",
                        "description": "Measurement variables to return per record, for example wtmp (water temp), atmp (air temp), wspd (wind speed). station, longitude, latitude, and time are always included. Leave empty to use wtmp, atmp, wspd.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startTime": {
                        "title": "Start time (UTC)",
                        "type": "string",
                        "description": "Lower bound of the time window in ISO 8601 UTC, for example 2026-05-14T21:00:00Z. Leave empty to auto-select a recent one hour window from the dataset's latest available data."
                    },
                    "endTime": {
                        "title": "End time (UTC)",
                        "type": "string",
                        "description": "Upper bound of the time window in ISO 8601 UTC, for example 2026-05-14T22:00:00Z. Leave empty to auto-select the dataset's latest available timestamp."
                    },
                    "stationFilter": {
                        "title": "Station filter",
                        "type": "string",
                        "description": "Optional exact station ID to restrict results to a single station, for example 41002. Leave empty to include all stations in the time window."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
