# Ventusky Weather Forecast Scraper (`xtracto/ventusky-weather-scraper`) Actor

Lightweight weather & air quality scraper for Ventusky. Get hourly, 8-day, and 14-day forecasts globally without expensive API keys or heavy browser automation.

- **URL**: https://apify.com/xtracto/ventusky-weather-scraper.md
- **Developed by:** [Xtractoo](https://apify.com/xtracto) (community)
- **Categories:** Integrations, Other, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Ventusky Weather Scraper

Extract real-time weather forecasts directly from [ventusky.com](https://www.ventusky.com) using reverse-engineered HTTP endpoints - **no browser, no Playwright, no API key required.**

Input a list of coordinates or city names, get back structured JSON with current conditions, hourly & 8-day forecasts, 14-day meteogram summaries, and air quality data. Each location costs **1–2 HTTP calls** and completes in under **1 second** (without AQI) or 2–6 seconds (with AQI).

---

### Why use this Actor?

| | This Actor | Official API | Browser scraping |
|---|---|---|---|
| **Cost** | Free (Ventusky has no public API) | N/A | High memory |
| **Speed** | ~0.4s per location | - | ~5–15s per page |
| **Data depth** | Current + 25h hourly + 8-day daily + 14-day meteogram | - | Same, slower |
| **AQI** | ✅ Real-time WAQI data | - | ✅ |
| **Infrastructure** | Lightweight HTTP | - | Chromium required |
| **Scales to 1,000+ locs** | ✅ Concurrent, configurable | - | Memory-constrained |

---

### Use Cases

- **Weather dashboards** - Embedded forecasts for apps, websites, IoT dashboards
- **Agriculture & logistics** - Daily precipitation, gust, snow outlook for route planning
- **Research & datasets** - Bulk weather data collection across hundreds of cities
- **Alert systems** - Poll every 30 min, trigger webhooks on `rain_probability > 70%`
- **Travel apps** - Pre-trip 8-day forecast + air quality for any destination worldwide
- etc...

---

### Input

```json
{
  "locations": [
    { "lat": -6.2088, "lon": 106.8456, "label": "Jakarta" },
    { "lat": 40.7128, "lon": -74.006,  "label": "New York" },
    { "city": "Tokyo",  "label": "Tokyo" },
    { "city": "London", "label": "London" }
  ],
  "skipAqi": false,
  "maxConcurrency": 3
}
````

#### Input fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `locations` | array | ✅ | - | List of locations to scrape |
| `locations[].lat` | number | - | - | Latitude in decimal degrees (e.g. `-6.2088`) |
| `locations[].lon` | number | - | - | Longitude in decimal degrees (e.g. `106.8456`) |
| `locations[].city` | string | - | - | City/place name instead of coordinates. Auto-geocoded via Nominatim OSM. |
| `locations[].label` | string | - | - | Optional human-readable tag, included in `_meta.label` |
| `skipAqi` | boolean | - | `false` | Skip the WAQI AQI API call. Saves 1–5s per location when air quality data is not needed. |
| `maxConcurrency` | integer | - | `3` | Max locations scraped simultaneously (1–10). |

> Each location must have **either** `lat` + `lon` **or** `city`. If both are given, `lat`/`lon` takes priority.

***

### Sample Output

One dataset item per location. Below is real output for **New York** (April 14, 2026):

```json
{
  "_meta": {
    "label": "New York",
    "lat": 40.7128,
    "lon": -74.006,
    "elapsed_s": 5.21
  },
  "location": {
    "name": "New York",
    "latitude": "40°42'N",
    "longitude": "74°0'W",
    "elevation_m": null,
    "timezone": "America/New_York (UTC-4)",
    "coordinates_raw": "40.71;-74.01;New York;new-york"
  },
  "current_weather": {
    "condition": "clear sky",
    "temperature": "16.7 °C",
    "wind_speed": "11 km/h",
    "pressure": "1016 hPa",
    "visibility": "16 km",
    "clouds": "0 %",
    "station_info": "Weather report from station Manhattan/dwntwn, Distance: 2 km (06:56 2026/04/14)"
  },
  "hourly_forecast": [
    {
      "time": "08:00",
      "time_epoch": 1776171600,
      "condition": "clear sky",
      "temperature": "19 °C",
      "precipitation": "0 mm",
      "rain_probability": "0 %",
      "wind_direction": "SW",
      "wind_speed": "4 km/h"
    },
    {
      "time": "09:00",
      "time_epoch": 1776175200,
      "condition": "clear sky",
      "temperature": "22 °C",
      "precipitation": "0 mm",
      "rain_probability": "0 %",
      "wind_direction": "S",
      "wind_speed": "3 km/h"
    },
    // ... 14 more today slots ...
    {
      "time": "00:00  tomorrow",
      "time_epoch": 1776229200,
      "condition": "overcast",
      "temperature": "21 °C",
      "precipitation": "0 mm",
      "rain_probability": "10 %",
      "wind_direction": "SW",
      "wind_speed": "18 km/h"
    }
    // ... 8 more tomorrow slots (total 25 hourly slots)
  ],
  "daily_forecast": [
    {
      "date": "2026/04/15",
      "slots": [
        {
          "time": "01:00",
          "time_epoch": 1776232800,
          "temperature": "20 °C",
          "condition": "overcast",
          "precipitation": "0 mm",
          "wind_speed": "16 km/h",
          "gust_speed": "32 km/h",
          "wind_direction": "SW",
          "wind_direction_deg": 225,
          "rain_probability": "10 %"
        },
        {
          "time": "04:00",
          "time_epoch": 1776243600,
          "temperature": "18 °C",
          "condition": "clear sky",
          "precipitation": "0 mm",
          "wind_speed": "7 km/h",
          "gust_speed": "18 km/h",
          "wind_direction": "SW",
          "wind_direction_deg": 225,
          "rain_probability": "0 %"
        }
        // ... 6 more slots per day (07:00, 10:00, 13:00, 16:00, 19:00, 22:00)
      ]
    }
    // ... 7 more days (2026/04/16 through 2026/04/22, total 8 days × 8 slots)
  ],
  "meteogram": {
    "timezone": "America/New_York",
    "days": [
      {
        "date": "14/04/2026",
        "date_epoch": 1776142800,
        "day": "Tue",
        "min_temp": 17,
        "max_temp": 31,
        "rain_total_mm": 0.3,
        "gust_kmh": 40,
        "snow_cm": 0.0,
        "weather_symbol": 1
      },
      {
        "date": "15/04/2026",
        "date_epoch": 1776229200,
        "day": "Wed",
        "min_temp": 18,
        "max_temp": 30,
        "rain_total_mm": 1.0,
        "gust_kmh": 36,
        "snow_cm": 0.0,
        "weather_symbol": 2
      }
      // ... 12 more days (total 14 days, through 2026/04/27)
    ]
  },
  "air_quality": {
    "quality": "Good",
    "quality_index": 0,
    "description": "Air quality index (marked as AQI) is developed by Environmental Protection Agency...",
    "value": 55,
    "station_within_range": true,
    "station_name": "New York",
    "station_dist_km": 0.0,
    "dominant_pollutant": "pm25",
    "pollutants": {
      "pm25": 55,
      "t": 19.4,
      "h": 79.6,
      "p": 1017.5,
      "w": 3.5
    }
  }
}
```

#### Output field reference

##### `_meta`

| Field | Description |
|---|---|
| `label` | The `label` value from the input (if provided) |
| `lat` / `lon` | Resolved coordinates used for the request |
| `elapsed_s` | Total scrape time for this location in seconds |

##### `location`

| Field | Description |
|---|---|
| `name` | Location display name from Ventusky |
| `latitude` / `longitude` | DMS-formatted coordinates (e.g. `"40°42'N"`) |
| `elevation_m` | Elevation in meters, or `null` if not shown |
| `timezone` | IANA timezone name + UTC offset (e.g. `"America/New_York (UTC-4)"`) |
| `coordinates_raw` | Internal Ventusky coordinate string |

##### `current_weather`

Current conditions from the nearest weather station.

| Field | Description |
|---|---|
| `condition` | Text description of current sky/precipitation (e.g. `"clear sky"`) |
| `temperature` | Temperature with unit (e.g. `"16.7 °C"`) |
| `wind_speed` | Wind speed (e.g. `"11 km/h"`) |
| `pressure` | Atmospheric pressure (e.g. `"1016 hPa"`) |
| `visibility` | Visibility distance (e.g. `"16 km"`) |
| `clouds` | Cloud cover percentage |
| `cloud_base` | Cloud base altitude (when clouds are present) |
| `station_info` | Source station name, distance, and observation time |

##### `hourly_forecast` - 25 hourly slots

Today's remaining hours + next morning. Fields per slot:

| Field | Description |
|---|---|
| `time` | Local time label (e.g. `"17:00"`, `"02:00  tomorrow"`) |
| `time_epoch` | UTC Unix timestamp of the slot |
| `condition` | Sky/precipitation condition text |
| `temperature` | Temperature string |
| `precipitation` | Precipitation in mm |
| `rain_probability` | Probability of rain (%) |
| `wind_direction` | Compass label (e.g. `"SW"`, `"NW"`) |
| `wind_speed` | Wind speed string |

##### `daily_forecast` - 8 days × 8 slots (every 3 hours)

Each day object has `date` (`YYYY/MM/DD`) and a `slots` array. Each slot:

| Field | Description |
|---|---|
| `time` / `time_epoch` | 3-hour slot time (01:00, 04:00 … 22:00) and UTC epoch |
| `temperature` | Temperature at this slot |
| `condition` | Weather condition text |
| `precipitation` | Precipitation mm |
| `wind_speed` / `gust_speed` | Wind and gust speed |
| `wind_direction` / `wind_direction_deg` | Direction label and degrees |
| `rain_probability` | Rain probability % (may be `null` for distant future slots) |

##### `meteogram` - 14-day daily summary

`days` array, one entry per calendar day.

| Field | Description |
|---|---|
| `date` / `date_epoch` | Date (DD/MM/YYYY) and UTC epoch of local midnight |
| `day` | Day abbreviation (e.g. `"Tue"`, `"Wed"`) |
| `min_temp` / `max_temp` | Daily min/max temperature (°C) |
| `rain_total_mm` | Total daily accumulated rain (mm) |
| `gust_kmh` | Max daily wind gust (km/h) |
| `snow_cm` | Total daily snow accumulation (cm) |
| `weather_symbol` | Ventusky weather symbol code |

##### `air_quality`

| Field | Description |
|---|---|
| `quality` | Human-readable band (e.g. `"Good"`, `"Moderate"`) |
| `quality_index` | 0=Good, 1=Moderate, 2=USG, 3=Unhealthy, 4=Very Unhealthy, 5=Hazardous |
| `description` | EPA AQI scale description |
| `value` | Numeric AQI (0–500), always returned (never suppressed) |
| `station_within_range` | `true` if nearest station ≤ 10 km |
| `station_name` | Name of the WAQI reporting station |
| `station_dist_km` | Distance to reporting station in km |
| `dominant_pollutant` | Primary pollutant key (e.g. `"pm25"`) |
| `pollutants` | Map of individual readings (`pm25`, `pm10`, `o3`, `t`, `h`, `p`, `w`) |

***

### Data Source & Freshness

- **Weather data:** [Ventusky.com](https://www.ventusky.com) - aggregates GFS, ECMWF, NAM, and other numerical weather models. Updated every 3–6 hours.
- **AQI data:** [WAQI (World Air Quality Index)](https://waqi.info) - real-time sensor data, updates hourly.
- **Geocoding:** [OpenStreetMap Nominatim](https://nominatim.org) - used only when `city` input is provided instead of coordinates.

***

### Sample Integrations

Retrieve results:

```
GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json
```

#### Zapier / Make

Use the **Apify** connector → "Watch Actor Run" trigger → parse `defaultDatasetId` → fetch dataset items.

#### Scheduled runs

Set a **Cron schedule** under Actor → Settings → Scheduling. Example for every 6 hours:

```
0 */6 * * *
```

#### API call example

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "locations": [
      { "city": "Jakarta" },
      { "lat": 40.7128, "lon": -74.006, "label": "New York" }
    ],
    "skipAqi": false,
    "maxConcurrency": 3
  }'
```

***

### Support

- Found a bug or the site structure changed? Open an issue on the Actor's page.
- For integration help, write in the Actor discussion forum on Apify Console.

# Actor input Schema

## `locations` (type: `array`):

List of coordinates to scrape weather for. Each item requires `lat` and `lon` (decimal degrees).

## `skipAqi` (type: `boolean`):

Skip the WAQI AQI API call. Use when AQI data is not needed or to reduce latency (~3–5s saved per location).

## `maxConcurrency` (type: `integer`):

Maximum locations scraped simultaneously.

## Actor input object example

```json
{
  "locations": [
    {
      "lat": -2.0932,
      "lon": 106.1512,
      "label": "Pangkalpinang"
    },
    {
      "city": "Jakarta",
      "label": "Jakarta"
    },
    {
      "city": "New York",
      "label": "New York"
    }
  ],
  "skipAqi": false,
  "maxConcurrency": 3
}
```

# 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 = {
    "locations": [
        {
            "lat": -2.0932,
            "lon": 106.1512,
            "label": "Pangkalpinang"
        },
        {
            "city": "Jakarta",
            "label": "Jakarta"
        },
        {
            "city": "New York",
            "label": "New York"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/ventusky-weather-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 = { "locations": [
        {
            "lat": -2.0932,
            "lon": 106.1512,
            "label": "Pangkalpinang",
        },
        {
            "city": "Jakarta",
            "label": "Jakarta",
        },
        {
            "city": "New York",
            "label": "New York",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("xtracto/ventusky-weather-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 '{
  "locations": [
    {
      "lat": -2.0932,
      "lon": 106.1512,
      "label": "Pangkalpinang"
    },
    {
      "city": "Jakarta",
      "label": "Jakarta"
    },
    {
      "city": "New York",
      "label": "New York"
    }
  ]
}' |
apify call xtracto/ventusky-weather-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ventusky Weather Forecast Scraper",
        "description": "Lightweight weather & air quality scraper for Ventusky. Get hourly, 8-day, and 14-day forecasts globally without expensive API keys or heavy browser automation.",
        "version": "1.0",
        "x-build-id": "D1w7vkcIHTVZJs89S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~ventusky-weather-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-ventusky-weather-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/xtracto~ventusky-weather-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-ventusky-weather-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/xtracto~ventusky-weather-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-ventusky-weather-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",
                "required": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "List of coordinates to scrape weather for. Each item requires `lat` and `lon` (decimal degrees).",
                        "items": {
                            "type": "object",
                            "properties": {
                                "lat": {
                                    "title": "Latitude",
                                    "type": "number",
                                    "description": "Decimal degrees, e.g. -2.0932. Required if city is not set."
                                },
                                "lon": {
                                    "title": "Longitude",
                                    "type": "number",
                                    "description": "Decimal degrees, e.g. 106.1512. Required if city is not set."
                                },
                                "city": {
                                    "title": "City name",
                                    "type": "string",
                                    "description": "City/place name instead of coordinates, e.g. 'Jakarta', 'New York'. Geocoded automatically via Nominatim."
                                },
                                "label": {
                                    "title": "Label",
                                    "type": "string",
                                    "description": "Optional human-readable name included in output _meta."
                                }
                            }
                        }
                    },
                    "skipAqi": {
                        "title": "Skip AQI fetch",
                        "type": "boolean",
                        "description": "Skip the WAQI AQI API call. Use when AQI data is not needed or to reduce latency (~3–5s saved per location).",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum locations scraped simultaneously.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
