# STAC Catalog Extractor (`datamule/stac-catalog-extractor`) Actor

Point at ANY STAC API — Earth Search, Planetary Computer, USGS & 100s of public satellite/EO catalogs. Search items by bbox/datetime/collection/cloud-cover or list collections; auto-paginate to flat rows + raw GeoJSON. Pay per item.

- **URL**: https://apify.com/datamule/stac-catalog-extractor.md
- **Developed by:** [Datamule](https://apify.com/datamule) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 items

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## STAC Catalog Extractor

A **generic "point at any STAC API" scraper**. [STAC](https://stacspec.org) (SpatioTemporal
Asset Catalog) is the OGC-blessed JSON standard behind **satellite / Earth-observation imagery
and geospatial catalogs** — one open specification spoken by **Element84 Earth Search** (AWS
open data), **Microsoft Planetary Computer**, **USGS LandsatLook**, **Digital Earth Africa /
Australia**, and hundreds of other public, no-auth catalogs. Give this actor a STAC API root
URL, optionally pick collections + an area + a time window + property filters, and it pages the
whole `/search` result set into clean, flat dataset rows plus a lossless `raw` GeoJSON Feature.

One actor, every STAC catalog — no per-instance scraper needed.

### What it does

- **Search items** — set the STAC root + one or more collections and any of a **bounding box**,
  **date/time window**, **property query** (e.g. cloud cover), item **ids**, or a GeoJSON
  **intersects** geometry, and it pulls every matching STAC Item, auto-following the
  `rel="next"` pagination link up to your **Max results**. Handles both STAC pagination styles:
  a POST `/search` body token *and* a GET `/search` next href.
- **Discover collections** — leave the search filters empty (or turn on **List collections
  only**) and it reads `{stacRoot}/collections` and returns one row per collection: id, title,
  license, spatial + temporal extent, and a ready-to-use search URL.
- **Normalized + raw** — each Item's well-known properties are promoted to stable columns
  (`id`, `collection`, `datetime`, `cloudCover`, `platform`, `gsd`, `geometryType`, …) while the
  full `properties`, `geometry`, `assets` and the untouched Feature (`raw`) are all preserved, so
  nothing is lost even though every catalog exposes different metadata.

### Example inputs

Recent low-cloud Sentinel-2 scenes over the San Francisco Bay Area (Element84 Earth Search, no auth):

```json
{ "stacRoot": "https://earth-search.aws.element84.com/v1", "collections": ["sentinel-2-l2a"], "bbox": [-122.6, 37.6, -122.2, 37.9], "datetime": "2024-06-01T00:00:00Z/2024-06-30T23:59:59Z", "query": { "eo:cloud_cover": { "lt": 20 } }, "maxResults": 200 }
````

The same search against Microsoft Planetary Computer — just change the root:

```json
{ "stacRoot": "https://planetarycomputer.microsoft.com/api/stac/v1", "collections": ["sentinel-2-l2a"], "bbox": [-122.6, 37.6, -122.2, 37.9], "datetime": "2024-06-01T00:00:00Z/2024-06-30T23:59:59Z", "maxResults": 100 }
```

Landsat over a point of interest, newest first (USGS):

```json
{ "stacRoot": "https://landsatlook.usgs.gov/stac-server", "collections": ["landsat-c2l2-sr"], "intersects": { "type": "Point", "coordinates": [-122.4, 37.8] }, "sortby": "-properties.datetime", "maxResults": 50 }
```

Discover what a catalog exposes:

```json
{ "stacRoot": "https://earth-search.aws.element84.com/v1", "listCollectionsOnly": true }
```

### Input reference

- `stacRoot` **(required)** — the STAC API root (not `/search` or `/collections`).
- `collections` — collection id(s) to search.
- `bbox` — `[west, south, east, north]` in WGS84 degrees (a 6-number 3D box is also accepted).
- `datetime` — RFC 3339 instant or range; open ranges with `..` (`2024-01-01T00:00:00Z/..`).
- `query` — STAC *query* extension filters, e.g. `{ "eo:cloud_cover": { "lt": 20 } }`.
- `filter` / `filterLang` — CQL2 *filter* extension (for servers that advertise it).
- `intersects` — a GeoJSON geometry, as an alternative to `bbox`.
- `ids` — fetch specific Item id(s) directly.
- `sortby` — e.g. `-properties.datetime` (server must support the *sort* class).
- `limit` — server-side page size (the actor paginates regardless).
- `maxResults` — total item cap across all pages (default 1000).

### Authentication

**None required** for the public catalogs (Earth Search, Planetary Computer, USGS, Digital
Earth). For gated deployments supply a **Bearer token** and/or **Extra request headers** — both
optional, never required, and the token is never logged.

### Output

One dataset item per STAC Item, with normalized columns plus:

- `_stacRoot` / `_mode` — the source catalog and whether the row is an `item` or a `collection`.
- `geometry` — the item footprint (GeoJSON), `assets` — the downloadable asset map (COGs,
  thumbnails, metadata), and `properties` — the full STAC property bag.
- `raw` — the complete, untouched STAC Feature.

A search that matches nothing returns **0 items, not an error**.

### Pricing

**Pay per item** — you're charged one `item` event per record returned (one per collection in
discovery mode). A search that matches nothing costs nothing.

### Notes

- Speaks STAC API 1.0.0 item-search; handles POST and GET `/search`, and both next-link
  pagination styles (POST body token, GET href token).
- Not affiliated with or endorsed by the OGC, Element84, AWS, Microsoft, the USGS, or any target
  catalog. Respect each provider's terms and any per-asset licensing.

# Actor input Schema

## `stacRoot` (type: `string`):

The root URL of ANY STAC API (SpatioTemporal Asset Catalog). Examples: https://earth-search.aws.element84.com/v1 (Element84 / AWS open data), https://planetarycomputer.microsoft.com/api/stac/v1 (Microsoft Planetary Computer), https://landsatlook.usgs.gov/stac-server (USGS). Do NOT include /search or /collections — just the API root.

## `collections` (type: `array`):

Collection id(s) to search, e.g. sentinel-2-l2a, landsat-c2-l2, sentinel-1-grd. Leave EMPTY together with the other search filters to run in discovery mode (list every collection the catalog exposes). Turn on "List collections only" below to just browse what's available first.

## `listCollectionsOnly` (type: `boolean`):

When on, the actor only reads {stacRoot}/collections and returns one row per available collection (id, title, license, spatial/temporal extent, search URL) — it does NOT search any items. Use this to discover what a catalog exposes, then set Collections + a bbox/datetime to extract items.

## `bbox` (type: `array`):

Spatial filter as \[west, south, east, north] in WGS84 decimal degrees (a 6-number \[w,s,minZ,e,n,maxZ] 3D box is also accepted). Example for the San Francisco Bay Area: \[-122.6, 37.6, -122.2, 37.9]. Leave empty for no spatial filter.

## `datetime` (type: `string`):

Temporal filter in RFC 3339. A single instant (2024-06-15T00:00:00Z), a closed range (2024-06-01T00:00:00Z/2024-06-30T23:59:59Z), or an open range using ".." (2024-06-01T00:00:00Z/.. or ../2024-06-30T00:00:00Z). Leave empty for no time filter.

## `ids` (type: `array`):

Fetch specific STAC Item id(s) directly (e.g. S2B\_10SEG\_20240627\_0\_L2A). When set, this narrows the search to exactly these items. Leave empty to search by the filters above.

## `query` (type: `object`):

Property filters using the STAC `query` extension, as a JSON object of {property: {op: value}}. Example to keep only low-cloud scenes: {"eo:cloud\_cover": {"lt": 20}}. Supported ops depend on the server (eq, neq, lt, lte, gt, gte, in, startsWith …). Leave empty for none.

## `filter` (type: `object`):

Advanced filter using the STAC `filter` extension in CQL2-JSON, as a JSON object. Example: {"op":"<","args":\[{"property":"eo:cloud\_cover"},20]}. Only supported on servers that advertise the filter conformance class; use the simpler Property query above when unsure. Leave empty for none.

## `filterLang` (type: `string`):

Language for the CQL2 filter above. Usually cql2-json (the default). Only change if the target server requires cql2-text.

## `intersects` (type: `object`):

Spatial filter as a GeoJSON geometry object (Point, Polygon, etc.) — an alternative to the bounding box for non-rectangular areas of interest. Example: {"type":"Point","coordinates":\[-122.4,37.8]}. Leave empty to use the bbox instead.

## `sortby` (type: `string`):

Sort order (STAC `sort` extension), e.g. -properties.datetime for newest first, or +properties.eo:cloud\_cover for least-cloudy first. Only honored by servers that advertise the sort conformance class. Leave empty for the server default order.

## `limit` (type: `integer`):

Server-side page size requested per /search call (the actor auto-follows the rel="next" link regardless). Most servers cap this around 100–1000. Leave at the default unless you have a reason to change it.

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

Maximum total number of items to pull across all pages (the actor auto-paginates until this cap or the result set is exhausted). Each returned item is one billable event. Default 25.

## `bearerToken` (type: `string`):

Optional OAuth2 bearer token for gated STAC deployments. Sent as Authorization: Bearer \*\*\*. NOT required for public catalogs (Earth Search, Planetary Computer, USGS) — leave empty. Never logged.

## `extraHeaders` (type: `object`):

Optional extra HTTP headers to send with every request, as a JSON object, e.g. {"Ocp-Apim-Subscription-Key": "..."} for a gated deployment. Leave empty for public catalogs.

## Actor input object example

```json
{
  "stacRoot": "https://earth-search.aws.element84.com/v1",
  "collections": [
    "sentinel-2-l2a"
  ],
  "listCollectionsOnly": false,
  "bbox": [
    -122.6,
    37.6,
    -122.2,
    37.9
  ],
  "datetime": "2024-06-01T00:00:00Z/2024-06-30T23:59:59Z",
  "filterLang": "cql2-json",
  "limit": 100,
  "maxResults": 25
}
```

# 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 = {
    "stacRoot": "https://earth-search.aws.element84.com/v1",
    "collections": [
        "sentinel-2-l2a"
    ],
    "bbox": [
        -122.6,
        37.6,
        -122.2,
        37.9
    ],
    "datetime": "2024-06-01T00:00:00Z/2024-06-30T23:59:59Z",
    "limit": 100,
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamule/stac-catalog-extractor").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 = {
    "stacRoot": "https://earth-search.aws.element84.com/v1",
    "collections": ["sentinel-2-l2a"],
    "bbox": [
        -122.6,
        37.6,
        -122.2,
        37.9,
    ],
    "datetime": "2024-06-01T00:00:00Z/2024-06-30T23:59:59Z",
    "limit": 100,
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("datamule/stac-catalog-extractor").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 '{
  "stacRoot": "https://earth-search.aws.element84.com/v1",
  "collections": [
    "sentinel-2-l2a"
  ],
  "bbox": [
    -122.6,
    37.6,
    -122.2,
    37.9
  ],
  "datetime": "2024-06-01T00:00:00Z/2024-06-30T23:59:59Z",
  "limit": 100,
  "maxResults": 25
}' |
apify call datamule/stac-catalog-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datamule/stac-catalog-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "STAC Catalog Extractor",
        "description": "Point at ANY STAC API — Earth Search, Planetary Computer, USGS & 100s of public satellite/EO catalogs. Search items by bbox/datetime/collection/cloud-cover or list collections; auto-paginate to flat rows + raw GeoJSON. Pay per item.",
        "version": "0.1",
        "x-build-id": "rOPHiicUs8yKNiE7e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamule~stac-catalog-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamule-stac-catalog-extractor",
                "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/datamule~stac-catalog-extractor/runs": {
            "post": {
                "operationId": "runs-sync-datamule-stac-catalog-extractor",
                "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/datamule~stac-catalog-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-datamule-stac-catalog-extractor",
                "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",
                "required": [
                    "stacRoot"
                ],
                "properties": {
                    "stacRoot": {
                        "title": "STAC API root URL",
                        "type": "string",
                        "description": "The root URL of ANY STAC API (SpatioTemporal Asset Catalog). Examples: https://earth-search.aws.element84.com/v1 (Element84 / AWS open data), https://planetarycomputer.microsoft.com/api/stac/v1 (Microsoft Planetary Computer), https://landsatlook.usgs.gov/stac-server (USGS). Do NOT include /search or /collections — just the API root."
                    },
                    "collections": {
                        "title": "Collections",
                        "type": "array",
                        "description": "Collection id(s) to search, e.g. sentinel-2-l2a, landsat-c2-l2, sentinel-1-grd. Leave EMPTY together with the other search filters to run in discovery mode (list every collection the catalog exposes). Turn on \"List collections only\" below to just browse what's available first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listCollectionsOnly": {
                        "title": "List collections only (discovery)",
                        "type": "boolean",
                        "description": "When on, the actor only reads {stacRoot}/collections and returns one row per available collection (id, title, license, spatial/temporal extent, search URL) — it does NOT search any items. Use this to discover what a catalog exposes, then set Collections + a bbox/datetime to extract items.",
                        "default": false
                    },
                    "bbox": {
                        "title": "Bounding box (bbox)",
                        "type": "array",
                        "description": "Spatial filter as [west, south, east, north] in WGS84 decimal degrees (a 6-number [w,s,minZ,e,n,maxZ] 3D box is also accepted). Example for the San Francisco Bay Area: [-122.6, 37.6, -122.2, 37.9]. Leave empty for no spatial filter."
                    },
                    "datetime": {
                        "title": "Date/time window",
                        "type": "string",
                        "description": "Temporal filter in RFC 3339. A single instant (2024-06-15T00:00:00Z), a closed range (2024-06-01T00:00:00Z/2024-06-30T23:59:59Z), or an open range using \"..\" (2024-06-01T00:00:00Z/.. or ../2024-06-30T00:00:00Z). Leave empty for no time filter."
                    },
                    "ids": {
                        "title": "Item IDs",
                        "type": "array",
                        "description": "Fetch specific STAC Item id(s) directly (e.g. S2B_10SEG_20240627_0_L2A). When set, this narrows the search to exactly these items. Leave empty to search by the filters above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Property query (STAC query extension)",
                        "type": "object",
                        "description": "Property filters using the STAC `query` extension, as a JSON object of {property: {op: value}}. Example to keep only low-cloud scenes: {\"eo:cloud_cover\": {\"lt\": 20}}. Supported ops depend on the server (eq, neq, lt, lte, gt, gte, in, startsWith …). Leave empty for none."
                    },
                    "filter": {
                        "title": "CQL2 filter (STAC filter extension)",
                        "type": "object",
                        "description": "Advanced filter using the STAC `filter` extension in CQL2-JSON, as a JSON object. Example: {\"op\":\"<\",\"args\":[{\"property\":\"eo:cloud_cover\"},20]}. Only supported on servers that advertise the filter conformance class; use the simpler Property query above when unsure. Leave empty for none."
                    },
                    "filterLang": {
                        "title": "Filter language",
                        "type": "string",
                        "description": "Language for the CQL2 filter above. Usually cql2-json (the default). Only change if the target server requires cql2-text.",
                        "default": "cql2-json"
                    },
                    "intersects": {
                        "title": "Intersects geometry (GeoJSON)",
                        "type": "object",
                        "description": "Spatial filter as a GeoJSON geometry object (Point, Polygon, etc.) — an alternative to the bounding box for non-rectangular areas of interest. Example: {\"type\":\"Point\",\"coordinates\":[-122.4,37.8]}. Leave empty to use the bbox instead."
                    },
                    "sortby": {
                        "title": "Sort by",
                        "type": "string",
                        "description": "Sort order (STAC `sort` extension), e.g. -properties.datetime for newest first, or +properties.eo:cloud_cover for least-cloudy first. Only honored by servers that advertise the sort conformance class. Leave empty for the server default order."
                    },
                    "limit": {
                        "title": "Page size",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Server-side page size requested per /search call (the actor auto-follows the rel=\"next\" link regardless). Most servers cap this around 100–1000. Leave at the default unless you have a reason to change it.",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total number of items to pull across all pages (the actor auto-paginates until this cap or the result set is exhausted). Each returned item is one billable event. Default 25.",
                        "default": 25
                    },
                    "bearerToken": {
                        "title": "Bearer token (optional)",
                        "type": "string",
                        "description": "Optional OAuth2 bearer token for gated STAC deployments. Sent as Authorization: Bearer ***. NOT required for public catalogs (Earth Search, Planetary Computer, USGS) — leave empty. Never logged."
                    },
                    "extraHeaders": {
                        "title": "Extra request headers",
                        "type": "object",
                        "description": "Optional extra HTTP headers to send with every request, as a JSON object, e.g. {\"Ocp-Apim-Subscription-Key\": \"...\"} for a gated deployment. Leave empty for public catalogs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
