# NOAA ERDDAP Dataset Catalog Scraper — Ocean & Climate Data (`compute-edge/erddap-datasets-scraper`) Actor

Catalog every dataset published by any NOAA ERDDAP server (CoastWatch, AOML, ICOADS, Upwell, and others). Filter by title, institution, or data type (grid vs table). Returns dataset IDs, summaries, and direct griddap/tabledap/WMS/FGDC URLs for oceanographic and climate research pipelines.

- **URL**: https://apify.com/compute-edge/erddap-datasets-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **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.

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

## NOAA ERDDAP Dataset Catalog Scraper

Catalog **every dataset** published by any NOAA ERDDAP server — the authoritative source for oceanographic, climate, and atmospheric data. This Actor fetches the complete dataset index from NOAA's Earth System Research Laboratories (ESRL) ERDDAP network and provides structured access to dataset metadata, direct data access URLs (griddap, tabledap, WMS), and full catalog URLs for scientific research pipelines.

ERDDAP servers are deployed across NOAA's ecosystem: CoastWatch (coastal oceanography), AOML (Atlantic Oceanographic), ICOADS (climate observations), Upwell (real-time environmental data), and others. This Actor discovers and catalogs datasets across any publicly accessible ERDDAP instance.

### Key Features

- **Complete dataset enumeration** — Fetch 100+ datasets per ERDDAP server with pagination
- **Multi-server support** — Query any NOAA ERDDAP server (CoastWatch, AOML, ICOADS, Upwell, etc.) or custom ERDDAP instances
- **Flexible filtering** — Filter by dataset title, institution, or data type (gridded vs. tabular)
- **Full metadata extraction** — Dataset ID, title, summary, institution, access URLs (griddap, tabledap, WMS, FGDC, ISO 19115)
- **Direct data access URLs** — Pre-built URLs for each dataset's griddap/tabledap interface, WMS service, metadata records
- **No authentication required** — Public ERDDAP APIs, no credentials needed
- **Scientific pipeline ready** — Clean JSON output structured for integration with data processing workflows, Jupyter notebooks, RAG systems

### Use Cases

- **Scientific data discovery** — Build searchable catalogs of oceanographic, climate, and atmospheric datasets
- **Data integration pipelines** — Automatically discover and ingest NOAA datasets into your research infrastructure
- **Climate & weather research** — Index datasets by institution (NOAA regional offices, universities, research organizations)
- **Environmental monitoring** — Discover real-time and historical datasets (sea surface temperature, wind, currents, precipitation)
- **Reproducible science** — Capture metadata snapshots of datasets used in analyses (versioning, attribution, availability)
- **Data governance** — Audit which datasets are available, accessible, and updated across NOAA ERDDAP network
- **RAG pipeline ingestion** — Structured dataset metadata ready for LLM-based research assistant systems

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `datasetId` | string | Unique ERDDAP dataset identifier (e.g., `erdSST3day`, `jplG1SST`) |
| `title` | string | Human-readable dataset title |
| `summary` | string | Dataset description and scientific context |
| `institution` | string | Data provider (NOAA CoastWatch, AOML, ICOADS, etc.) |
| `accessible` | string | Access status ("true" if publicly accessible) |
| `griddapUrl` | string | Direct URL to gridded data access interface (null if N/A) |
| `tabledapUrl` | string | Direct URL to tabular data access interface (null if N/A) |
| `wmsUrl` | string | Web Map Service URL for visualization (null if N/A) |
| `infoUrl` | string | Dataset information and metadata page |
| `makeAGraphUrl` | string | Interactive data viewer URL |
| `fgdcUrl` | string | FGDC XML metadata record URL |
| `iso19115Url` | string | ISO 19115 XML metadata record URL |
| `backgroundInfoUrl` | string | Full dataset documentation URL |
| `rssUrl` | string | RSS feed for dataset updates |
| `server` | string | ERDDAP server base URL |

### How to Scrape NOAA ERDDAP Dataset Catalogs

#### 1. Open the Actor

Navigate to the **NOAA ERDDAP Dataset Catalog Scraper** on Apify Store and click **Start**.

#### 2. Configure the Input (Optional)

The Actor comes with sensible defaults. Customize as needed:

- **ERDDAP Server URL** — Base URL of the ERDDAP instance to catalog
  - Default: `https://coastwatch.pfeg.noaa.gov/erddap` (CoastWatch — most comprehensive)
  - Alternatives:
    - `https://upwell.pfeg.noaa.gov/erddap` (real-time coastal data)
    - `https://erddap.aoml.noaa.gov/hdb/erddap` (Atlantic Oceanographic & Meteorological Laboratory)
    - `https://erddap.icoads.noaa.gov/erddap` (International Comprehensive Ocean-Atmosphere Data Set)

- **Title Contains** — Filter to datasets whose title includes this phrase (case-insensitive)
  - Example: "temperature" will match "Sea Surface Temperature", "GHRSST Temperature"

- **Institution Contains** — Filter to datasets from a specific data provider
  - Example: "CoastWatch" will match all NOAA CoastWatch datasets

- **Data Type Filter** — Limit to specific data format
  - `any` (default) — All dataset types
  - `griddap` — Gridded data (netCDF-style arrays, e.g., satellite sea surface temperature)
  - `tabledap` — Tabular data (CSV-style rows, e.g., buoy observations, station time series)

- **Max Results** — Maximum number of datasets to return (default 1000, max 20,000)

#### 3. Click Start

The Actor will fetch the catalog from your chosen ERDDAP server, apply filters, and return structured dataset metadata.

#### 4. Download Results

From the **Dataset** tab, export as JSON, CSV, Excel, or XML. Use the JSON output directly in Python/R scripts or import into data tools.

### Input Example

```json
{
    "serverUrl": "https://coastwatch.pfeg.noaa.gov/erddap",
    "titleContains": "temperature",
    "institutionContains": "CoastWatch",
    "dataTypeFilter": "griddap",
    "maxResults": 50
}
````

### Output Example

```json
{
    "datasetId": "erdSST3day",
    "title": "NOAA Global SST Analysis V3",
    "summary": "NOAA OI SST provides daily global sea surface temperature from blended satellite and in-situ measurements on a 0.25 degree grid.",
    "institution": "NOAA CoastWatch",
    "accessible": "true",
    "griddapUrl": "https://coastwatch.pfeg.noaa.gov/erddap/griddap/erdSST3day",
    "tabledapUrl": null,
    "wmsUrl": "https://coastwatch.pfeg.noaa.gov/erddap/wms/erdSST3day",
    "infoUrl": "https://coastwatch.pfeg.noaa.gov/erddap/info/erdSST3day/index.html",
    "makeAGraphUrl": "https://coastwatch.pfeg.noaa.gov/erddap/tabledap/erdSST3day.htmlTable",
    "fgdcUrl": "https://coastwatch.pfeg.noaa.gov/erddap/metadata/fgdc/xml/erdSST3day_fgdc.xml",
    "iso19115Url": "https://coastwatch.pfeg.noaa.gov/erddap/metadata/iso19115/xml/erdSST3day_iso19115.xml",
    "backgroundInfoUrl": "https://coastwatch.pfeg.noaa.gov/erddap/info/erdSST3day",
    "rssUrl": "https://coastwatch.pfeg.noaa.gov/erddap/rss/erdSST3day.rss",
    "server": "https://coastwatch.pfeg.noaa.gov/erddap"
}
```

### Pricing

This Actor fetches dataset catalogs from NOAA ERDDAP public APIs.

- **Cost per run**: ~$0.001-0.002 (API request, no browser required)
- **Actor start event**: Default platform rate
- **Per-result pricing**: $0.002/dataset

A typical run catalogs 100-500 datasets (CoastWatch server). Full pagination of a large ERDDAP instance (2000+ datasets) takes 2-5 minutes and costs approximately $2-5 in actor fees plus minimal Apify compute.

### Use Cases Explained

#### Scientific Data Discovery

Researchers can search the ERDDAP network for datasets matching their study area or variables without manually visiting each server. Example: "Find all datasets with 'chlorophyll' in the title from NOAA CoastWatch."

#### Climate & Weather Data Processing

Climate researchers use this to automatically discover and ingest NOAA datasets. The output includes direct griddap/tabledap URLs ready for subsetting in Python (via netCDF4) or R (via rerddap).

#### Reproducible Science

Capture the metadata and access URLs of datasets used in a published analysis. Store this as supplementary material to ensure future readers can locate and cite the exact datasets.

#### Environmental Monitoring Dashboards

Ingest ERDDAP dataset metadata into a data catalog system. Alert teams when new datasets are added or updated.

#### Data Governance & Compliance

Audit access to NOAA data across your organization. Discover which datasets are available and track their update frequency.

### Example: Integrating into Python Workflow

```python
import json
import requests
import xarray as xr

## Download dataset list from Actor output
with open('erddap_datasets.json') as f:
    datasets = json.load(f)

## Filter to sea surface temperature datasets
sst_datasets = [d for d in datasets if 'temperature' in d['title'].lower()]

## For each dataset, fetch metadata and load data
for dataset in sst_datasets[:3]:
    dataset_id = dataset['datasetId']
    griddap_url = dataset['griddapUrl']
    
    if griddap_url:
        ## Construct netCDF download URL
        nc_url = f"{griddap_url}.nc?time[0:100]&latitude[0:10]&longitude[0:10]"
        print(f"Loading {dataset_id}...")
        try:
            ds = xr.open_dataset(nc_url)
            print(f"  Variables: {list(ds.data_vars)}")
        except Exception as e:
            print(f"  Error: {e}")
```

### FAQ

#### Which ERDDAP servers does this Actor support?

This Actor works with any public ERDDAP server. NOAA operates several regional instances:

- **CoastWatch** (default): https://coastwatch.pfeg.noaa.gov/erddap — Most datasets, ocean-focused
- **Upwell**: https://upwell.pfeg.noaa.gov/erddap — Real-time environmental data
- **AOML**: https://erddap.aoml.noaa.gov/hdb/erddap — Atlantic region oceanography
- **ICOADS**: https://erddap.icoads.noaa.gov/erddap — International climate observations

You can also query university or research organization ERDDAP instances.

#### How many datasets are on a typical ERDDAP server?

CoastWatch has 200+ datasets. Smaller regional instances may have 50-100. The Actor will paginate through all available datasets up to your `maxResults` limit.

#### What's the difference between griddap and tabledap?

- **griddap** — Gridded data access. Returns multi-dimensional arrays (e.g., sea surface temperature at lat/lon/time). Optimized for spatial/temporal subsetting.
- **tabledap** — Tabular data access. Returns rows like a CSV or SQL query (e.g., individual buoy measurements). Optimized for filtering by attributes.

Both can return netCDF, CSV, JSON, or other formats. Use the URLs provided to construct custom data download requests.

#### How often is ERDDAP data updated?

ERDDAP servers catalog real-time satellite data, model output, and historical observations. Update frequencies vary by dataset: real-time (daily or more frequent), monthly, or static. Check the dataset's RSS feed (included in output) for update notifications.

#### Is ERDDAP data free to use?

Yes. NOAA ERDDAP data is public and typically available under the NOAA Open Data policy or Creative Commons licenses. See the dataset's metadata page for licensing details. Most are freely available for research, education, and operational use.

#### How do I download actual data from these datasets?

Use the `griddapUrl` or `tabledapUrl` included in the output. These URLs point to ERDDAP's data access interface. For example:

- Gridded data: `{griddapUrl}.nc?variable[time][lat][lon]` to download netCDF
- Tabular data: `{tabledapUrl}.csv?select=variables&where=constraints` to download CSV

ERDDAP supports multiple output formats (netCDF, CSV, JSON, GeoTIFF, etc.). See ERDDAP's API documentation for syntax.

#### Can I query datasets across multiple ERDDAP servers?

Run the Actor once per server. Results will include the `server` field so you can identify which server each dataset came from.

### Legal Disclaimer

This Actor accesses publicly available NOAA ERDDAP datasets. No authentication bypass or terms-of-service violation is involved. All data extracted is from public ERDDAP catalog APIs (`/info/index.json`). Users are responsible for ensuring their use of the extracted data complies with NOAA's Open Data policy and applicable licenses. For questions about data licensing, visit the NOAA ERDDAP documentation at https://coastwatch.pfeg.noaa.gov/erddap/information.html.

### Other Scrapers by SeatSignal

- [CISA Known Exploited Vulnerabilities (KEV) Scraper](https://apify.com/seatsignal/cisa-kev-scraper) — Extract CVE threat intelligence
- [NIST NVD Scraper](https://apify.com/seatsignal/nist-nvd-scraper) — Extract NIST National Vulnerability Database
- [NHTSA Vehicle Safety Scraper](https://apify.com/seatsignal/nhtsa-vehicle-safety-scraper) — Extract vehicle recalls
- [OSHA Inspections Scraper](https://apify.com/seatsignal/osha-inspections-scraper) — Extract OSHA inspection data
- [FDA OpenFDA Scraper](https://apify.com/seatsignal/fda-openfda-scraper) — Extract FDA drug and device safety

### Support

For issues, questions, or feature requests, contact the Actor developer through the Apify Store.

# Actor input Schema

## `serverUrl` (type: `string`):

Base URL of an ERDDAP server. Examples: 'https://coastwatch.pfeg.noaa.gov/erddap', 'https://upwell.pfeg.noaa.gov/erddap', 'https://erddap.aoml.noaa.gov/hdb/erddap', 'https://erddap.icoads.noaa.gov/erddap'.

## `titleContains` (type: `string`):

Filter by partial match on dataset title (case-insensitive). Leave blank to include all titles.

## `institutionContains` (type: `string`):

Filter by partial match on institution name (case-insensitive). Leave blank to include all institutions.

## `dataTypeFilter` (type: `string`):

Filter by data type: 'any' (all), 'griddap' (gridded data only), or 'tabledap' (table data only).

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

Maximum number of datasets to return. Default 1000, max 20000. Set to 0 for unlimited.

## Actor input object example

```json
{
  "serverUrl": "https://coastwatch.pfeg.noaa.gov/erddap",
  "titleContains": "",
  "institutionContains": "",
  "dataTypeFilter": "any",
  "maxResults": 1000
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/erddap-datasets-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/erddap-datasets-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 '{}' |
apify call compute-edge/erddap-datasets-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA ERDDAP Dataset Catalog Scraper — Ocean & Climate Data",
        "description": "Catalog every dataset published by any NOAA ERDDAP server (CoastWatch, AOML, ICOADS, Upwell, and others). Filter by title, institution, or data type (grid vs table). Returns dataset IDs, summaries, and direct griddap/tabledap/WMS/FGDC URLs for oceanographic and climate research pipelines.",
        "version": "0.1",
        "x-build-id": "NKwQdE9gf16vNIVBP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~erddap-datasets-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-erddap-datasets-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/compute-edge~erddap-datasets-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-erddap-datasets-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/compute-edge~erddap-datasets-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-erddap-datasets-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": {
                    "serverUrl": {
                        "title": "ERDDAP Server URL",
                        "type": "string",
                        "description": "Base URL of an ERDDAP server. Examples: 'https://coastwatch.pfeg.noaa.gov/erddap', 'https://upwell.pfeg.noaa.gov/erddap', 'https://erddap.aoml.noaa.gov/hdb/erddap', 'https://erddap.icoads.noaa.gov/erddap'.",
                        "default": "https://coastwatch.pfeg.noaa.gov/erddap"
                    },
                    "titleContains": {
                        "title": "Title Contains",
                        "type": "string",
                        "description": "Filter by partial match on dataset title (case-insensitive). Leave blank to include all titles.",
                        "default": ""
                    },
                    "institutionContains": {
                        "title": "Institution Contains",
                        "type": "string",
                        "description": "Filter by partial match on institution name (case-insensitive). Leave blank to include all institutions.",
                        "default": ""
                    },
                    "dataTypeFilter": {
                        "title": "Data Type Filter",
                        "enum": [
                            "any",
                            "griddap",
                            "tabledap"
                        ],
                        "type": "string",
                        "description": "Filter by data type: 'any' (all), 'griddap' (gridded data only), or 'tabledap' (table data only).",
                        "default": "any"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of datasets to return. Default 1000, max 20000. Set to 0 for unlimited.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
