# OnTheSnow.com Snow Report Scraper (`piquno/onthesnow-snow-report-scraper`) Actor

Scrape daily snow reports and live ski conditions from OnTheSnow.com — 2,000+ ski resorts worldwide. Snow depths, fresh snowfall (8-day history + 8-day forecast), open lifts/trails, surface conditions, snow reporter comments, webcams, and depth-vs-historical-average.

- **URL**: https://apify.com/piquno/onthesnow-snow-report-scraper.md
- **Developed by:** [Piquno](https://apify.com/piquno) (community)
- **Categories:** Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $150.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

## OnTheSnow.com Snow Report Scraper

Scrape **daily snow reports and live ski conditions** from [OnTheSnow.com](https://www.onthesnow.com/) — the world's most popular snow & ski conditions site (2,000+ resorts worldwide). Get snow depths, fresh snowfall, lifts open, trails open, surface conditions, snow reporter comments, webcams and more.

**No API key required.** Works for any ski country — US, Canada, Japan, France, Austria, Switzerland, Italy and 20+ others.

### What makes this Actor different

Most ski Actors give you **static resort facts** — elevation, slope length, prices. This one gives you **what's happening right now**:

- ✅ Today's snow depth at base, mid-mountain, and summit
- ✅ Fresh snowfall — last 24h, 48h, 72h, **plus full 8-day daily history**
- ✅ 8-day snowfall forecast
- ✅ Open lifts and trails (counts + percentage)
- ✅ Current surface conditions (Packed Powder, Spring Snow, Machine Groomed, etc.)
- ✅ Snow reporter narrative comments — what the resort staff actually said today
- ✅ Depth vs historical average — is this snowpack better or worse than usual?
- ✅ Live webcam streams (YouTube embed URLs) for every resort
- ✅ Terrain breakdown by difficulty (beginner/intermediate/advanced/expert)
- ✅ Operating schedule by day of week
- ✅ GPS coordinates, address, phone — for mapping and trip planning

Perfect companion to the static [Ski Resorts Worldwide Scraper](https://apify.com/piquno/ski-resorts-worldwide-scraper) — that one tells you *which resort to visit*, this one tells you *if it's good there right now*.

### What you can scrape

- **Any country**: 27 ski countries pre-listed (US, Canada, Japan, France, Austria, Switzerland, Italy, Germany, Norway, Sweden, Finland, Spain, Andorra, Czech Republic, Slovakia, Poland, Slovenia, Bulgaria, Romania, UK, Iceland, Australia, New Zealand, Chile, Argentina, South Korea, Turkey)
- **Custom resort URLs**: paste any specific `onthesnow.com` resort URLs to scrape only those
- **By status**: Open only (default), Weekends only, Closed (off-season — useful for projected opening dates), Permanently Closed, or All

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `country` | string | `"united-states"` | Country to scrape. Leave empty if using custom URLs. |
| `statusFilter` | string | `"open"` | `open` / `weekends` / `closed` / `permanently-closed` / `all` |
| `maxResorts` | integer | `100` | Cap on results per run. `0` = no limit. |
| `includeDetailEnrichment` | boolean | `true` | Fetch each resort's page for the killer fields (coords, comments, full history, webcams). Disable for a much faster, listing-only run. |
| `customResortUrls` | array | `[]` | Specific resort URLs to scrape. Overrides `country`. |
| `concurrency` | integer | `5` | Parallel requests during detail enrichment. |
| `units` | string | `"metric"` | `metric` (cm) or `imperial` (inches) |

#### Example input

```json
{
  "country": "japan",
  "statusFilter": "open",
  "maxResorts": 50,
  "includeDetailEnrichment": true,
  "units": "imperial"
}
````

Or scrape specific resorts directly:

```json
{
  "customResortUrls": [
    "https://www.onthesnow.com/utah/brighton-resort/skireport",
    "https://www.onthesnow.com/colorado/aspen-snowmass/skireport",
    "https://www.onthesnow.com/japan/niseko-united/skireport"
  ]
}
```

### Output

Every record is a single resort. With detail enrichment enabled, you get all of these fields:

#### Identity & location

| Field | Description |
|---|---|
| `uuid` | OnTheSnow internal ID |
| `name` | Resort name |
| `shortName` | Short version (e.g. "Mammoth" instead of "Mammoth Mountain Ski Area") |
| `slug` | URL-safe identifier |
| `url` | Direct link to snow report page |
| `region`, `regionSlug` | State / province / region |
| `country`, `state`, `countryCode` | Country and state codes |
| `corporateName` | Operating company name |
| `latitude`, `longitude` | GPS coordinates |
| `address`, `city`, `zip` | Full address |
| `phone`, `website`, `twitter` | Contact details |
| `image` | Header photo URL |
| `timezoneOffsetHours` | Local timezone offset from UTC |

#### Current status

| Field | Description |
|---|---|
| `status` | `"Open"` / `"Closed (off-season)"` / `"Weekends only"` / `"Permanently closed"` etc. |
| `statusCode` | Numeric code (1–6) |
| `openingDate`, `closingDate` | Projected season dates |
| `lastUpdated` | When the resort last reported conditions (ISO 8601) |

#### Snow conditions (today)

| Field | Description |
|---|---|
| `baseDepth`, `midDepth`, `summitDepth` | Current snow depth at each elevation |
| `snowLast24h`, `snowLast48h`, `snowLast72h` | Fresh snowfall windows |
| `surfaceType` | Surface conditions (Packed Powder, Spring Snow, etc.) |
| `historicalDepthAverages` | What depth this resort *usually* has on this date — for "above/below average" analysis |

#### Daily history & forecast

| Field | Description |
|---|---|
| `recentSnowfall` | Array of 8 days' historical daily snowfall: `[{date, snow}]` |
| `recentReportedStartDate`, `recentLastModified` | Reporting window timestamps |
| `forecast` | Array of 8 days' forecast daily snowfall: `[{date, snow}]` |
| `weatherDaily` | Detailed daily weather (high/low temp, wind speed/direction/gusts, weather type) for ~15 days history + forecast |
| `todayWeather` | Today's summary (temp at base/summit, wind, snow forecast) |

#### Mountain operations

| Field | Description |
|---|---|
| `liftsOpen`, `liftsTotal` | Lift counts |
| `liftDetails` | Per-lift names, types and statuses (when reported) |
| `runsOpen`, `runsTotal`, `runsOpenPercent` | Trail counts |
| `terrain` | Breakdown by difficulty: beginner/intermediate/advanced/expert — total runs, total length km, total % of mountain, plus open metrics |
| `schedule` | Operating hours by day of week (0 = Monday) |

#### Media & comments

| Field | Description |
|---|---|
| `snowReporterComment` | Narrative text from resort staff — current conditions in their own words |
| `webcams` | Array of `{title, image, videoStreamUrl, lastUpdated, isFeatured}` — includes YouTube embed URLs for live streams |
| `trailMapUrl` | Trail map image |

#### Sample output (Brighton Resort, Utah)

```json
{
  "uuid": "82",
  "name": "Brighton Resort",
  "slug": "brighton-resort",
  "url": "https://www.onthesnow.com/utah/brighton-resort/skireport",
  "region": "Utah",
  "country": "United States",
  "latitude": 40.59766657,
  "longitude": -111.5848171,
  "address": "12601 East Big Cotton Canyon",
  "phone": "(800) 873-5512",
  "status": "Open",
  "statusCode": 1,
  "baseDepth": 170.2,
  "snowLast24h": 7.6,
  "snowLast72h": 22.8,
  "surfaceType": "Packed Powder",
  "liftsOpen": 4,
  "liftsTotal": 9,
  "runsOpen": 23,
  "runsTotal": 67,
  "runsOpenPercent": 34,
  "recentSnowfall": [
    {"date": "2026-05-03", "snow": 0.0},
    {"date": "2026-05-04", "snow": 0.0},
    {"date": "2026-05-10", "snow": 7.6}
  ],
  "forecast": [
    {"date": "2026-05-11", "snow": 0.0},
    {"date": "2026-05-15", "snow": 3.0}
  ],
  "terrain": {
    "beginner":    {"totalRuns": 16, "totalLengthKm": 14.48, "totalPercent": 24},
    "intermediate":{"totalRuns": 24, "totalLengthKm": 21.89, "totalPercent": 36},
    "advanced":    {"totalRuns": 18, "totalLengthKm": 10.2,  "totalPercent": 27},
    "expert":      {"totalRuns":  9, "totalLengthKm":  8.21, "totalPercent": 13},
    "overall":     {"open": 23, "total": 67, "openPercent": 34}
  },
  "historicalDepthAverages": {"base": 153.0, "mid": 0.0, "summit": 132.0},
  "webcams": [
    {
      "title": "Majestic - Brighton Ski Resort",
      "videoStreamUrl": "https://www.youtube.com/embed/XLzKPufaAts",
      "lastUpdated": "2026-05-11T02:04:01+00:00"
    }
  ],
  "units": "cm"
}
```

### Use cases

- **Daily ski-condition dashboards** — schedule the Actor to run every morning and feed your app
- **Powder alerts** — trigger notifications when `snowLast24h` exceeds a threshold
- **Ski-trip planners** — combine `forecast` + `historicalDepthAverages` to recommend the best week to visit
- **Tour operator dashboards** — track lift/run open percentage to advise clients
- **Travel agencies & content sites** — show real-time conditions on resort pages
- **Off-season research** — use `statusFilter: closed` + `openingDate` to plan which resorts will be open when

### How it works

OnTheSnow.com is a Next.js single-page app — every page embeds a clean JSON blob (`__NEXT_DATA__`) with all the data its frontend uses. This Actor extracts that JSON directly instead of parsing HTML, which means:

- **Faster** — no CSS-selector overhead
- **More reliable** — no breakage when they tweak the layout
- **Richer** — picks up fields that aren't even rendered visibly (e.g. lift schedules, depth averages, webcam stream URLs)

### Limitations

- **Pagination cap**: when a country has more than 50 resorts in the same status (typically only the "Closed (off-season)" bucket), the listing page returns only the first 50 with full data. The Actor automatically supplements the remainder by enumerating the country's full resort guide and fetching each via detail enrichment — so you still get every resort, but only when `includeDetailEnrichment` is on.
- **Off-season data**: closed resorts haven't been refreshing snow conditions, so many of their fields are `null`. Their `openingDate` and identity data are still useful for trip planning.
- **Country coverage**: OnTheSnow's Japanese coverage is shallow (only ~5 major resorts: Niseko, Furano, Hakuba Valley, Kiroro, Rusutsu). For deeper Japan-specific data, use the Ski Resorts Worldwide Scraper (which covers skiresort.info).

### Tips

- **Default settings give you a fast, useful first run**: 100 open resorts in the US with full enrichment.
- **For daily monitoring**: set `statusFilter: open`, schedule the Actor to run every morning, and use webhooks to feed your downstream system.
- **Run cheaply during off-season**: set `includeDetailEnrichment: false` for a listing-only run that gives you status + projected opening dates at minimum cost.
- **Combine with our other ski Actor**: scrape this for live conditions, scrape `piquno/ski-resorts-worldwide-scraper` once per season for static resort details, and merge by resort name.

### Pricing

$0.15 per result — same as the Ski Resorts Worldwide Scraper. Each result is an information-dense record (full daily history + forecast + webcams + reporter comments + terrain breakdown).

# Actor input Schema

## `country` (type: `string`):

Country whose ski resorts to scrape. Leave empty if using Custom Resort URLs.

## `statusFilter` (type: `string`):

Filter resorts by current operating status. Defaults to Open only — closed/off-season resorts have stale data that hasn't refreshed in months.

## `maxResorts` (type: `integer`):

Maximum number of resorts to scrape from the country. Set 0 for no limit.

## `includeDetailEnrichment` (type: `boolean`):

Fetch each resort's individual page for the killer data: GPS coordinates, snow reporter comments, full 8-day daily snowfall history, 8-day forecast, terrain breakdown by difficulty, depth-vs-historical-average, webcam streams, lift schedule, address & phone. Turn off for a much faster, listing-only run.

## `customResortUrls` (type: `array`):

Paste specific resort URLs to scrape only those. Example: https://www.onthesnow.com/utah/brighton-resort/skireport — if provided, Country selector is ignored.

## `concurrency` (type: `integer`):

Number of parallel requests when enriching detail pages. Keep at 5 to avoid rate limits.

## `units` (type: `string`):

OnTheSnow stores everything in centimetres internally — choose whether the output uses metric (cm) or imperial (inches).

## Actor input object example

```json
{
  "country": "united-states",
  "statusFilter": "open",
  "maxResorts": 100,
  "includeDetailEnrichment": true,
  "customResortUrls": [],
  "concurrency": 5,
  "units": "metric"
}
```

# 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("piquno/onthesnow-snow-report-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("piquno/onthesnow-snow-report-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 piquno/onthesnow-snow-report-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=piquno/onthesnow-snow-report-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OnTheSnow.com Snow Report Scraper",
        "description": "Scrape daily snow reports and live ski conditions from OnTheSnow.com — 2,000+ ski resorts worldwide. Snow depths, fresh snowfall (8-day history + 8-day forecast), open lifts/trails, surface conditions, snow reporter comments, webcams, and depth-vs-historical-average.",
        "version": "1.0",
        "x-build-id": "QBfik1UBUE8myuvLz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piquno~onthesnow-snow-report-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piquno-onthesnow-snow-report-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/piquno~onthesnow-snow-report-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piquno-onthesnow-snow-report-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/piquno~onthesnow-snow-report-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piquno-onthesnow-snow-report-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": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "united-states",
                            "canada",
                            "japan",
                            "france",
                            "austria",
                            "switzerland",
                            "italy",
                            "germany",
                            "norway",
                            "sweden",
                            "finland",
                            "spain",
                            "andorra",
                            "czech-republic",
                            "slovakia",
                            "poland",
                            "slovenia",
                            "bulgaria",
                            "romania",
                            "united-kingdom",
                            "iceland",
                            "australia",
                            "new-zealand",
                            "chile",
                            "argentina",
                            "south-korea",
                            "turkey"
                        ],
                        "type": "string",
                        "description": "Country whose ski resorts to scrape. Leave empty if using Custom Resort URLs.",
                        "default": "united-states"
                    },
                    "statusFilter": {
                        "title": "Status filter",
                        "enum": [
                            "open",
                            "weekends",
                            "closed",
                            "permanently-closed",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter resorts by current operating status. Defaults to Open only — closed/off-season resorts have stale data that hasn't refreshed in months.",
                        "default": "open"
                    },
                    "maxResorts": {
                        "title": "Max resorts",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of resorts to scrape from the country. Set 0 for no limit.",
                        "default": 100
                    },
                    "includeDetailEnrichment": {
                        "title": "Include detail enrichment (recommended)",
                        "type": "boolean",
                        "description": "Fetch each resort's individual page for the killer data: GPS coordinates, snow reporter comments, full 8-day daily snowfall history, 8-day forecast, terrain breakdown by difficulty, depth-vs-historical-average, webcam streams, lift schedule, address & phone. Turn off for a much faster, listing-only run.",
                        "default": true
                    },
                    "customResortUrls": {
                        "title": "Custom resort URLs (optional)",
                        "type": "array",
                        "description": "Paste specific resort URLs to scrape only those. Example: https://www.onthesnow.com/utah/brighton-resort/skireport — if provided, Country selector is ignored.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Number of parallel requests when enriching detail pages. Keep at 5 to avoid rate limits.",
                        "default": 5
                    },
                    "units": {
                        "title": "Measurement units",
                        "enum": [
                            "metric",
                            "imperial"
                        ],
                        "type": "string",
                        "description": "OnTheSnow stores everything in centimetres internally — choose whether the output uses metric (cm) or imperial (inches).",
                        "default": "metric"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
