# Weather Forecast Actor (`aligned_sassafras/weather-forecast-actor`) Actor

- **URL**: https://apify.com/aligned\_sassafras/weather-forecast-actor.md
- **Developed by:** [Uma Mahesh](https://apify.com/aligned_sassafras) (community)
- **Categories:** Automation, Travel, Integrations
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 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

## 🌤️ Weather Forecast Actor

[![Apify](https://img.shields.io/badge/Apify-Actor-00A699?style=flat-square)](https://apify.com)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.3-blue?style=flat-square)](https://www.typescriptlang.org/)
[![License](https://img.shields.io/badge/license-MIT-green?style=flat-square)](LICENSE)

**Get accurate 7-day weather forecasts for any location worldwide using GPS coordinates.**

Built for the [Apify $1M Challenge](https://apify.com/challenge) 🏆

---

### ✨ Features

- 📍 **GPS-Based Forecasts** - Use precise latitude/longitude coordinates
- 📅 **7-Day Outlook** - Comprehensive weekly weather predictions
- 🌡️ **Flexible Units** - Support for both metric (Celsius) and imperial (Fahrenheit)
- ⚡ **Lightning Fast** - Executes in 1-3 seconds
- 📊 **Rich Data** - Temperature, humidity, wind, precipitation, and more
- 🔒 **Type-Safe** - Built with TypeScript for reliability
- 🌐 **Global Coverage** - Works for any location on Earth

---

### 🚀 Quick Start

#### Input Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `latitude` | number | ✅ Yes | GPS latitude (-90 to 90) |
| `longitude` | number | ✅ Yes | GPS longitude (-180 to 180) |
| `units` | string | No | `"metric"` (Celsius) or `"imperial"` (Fahrenheit). Default: `"metric"` |
| `apiKey` | string | ✅ Yes | OpenWeatherMap API key ([Get free key](https://openweathermap.org/api)) |

#### Example Input

```json
{
  "latitude": 40.7128,
  "longitude": -74.0060,
  "units": "metric",
  "apiKey": "your_openweathermap_api_key"
}
````

#### Example Output

```json
{
  "location": {
    "latitude": 40.7128,
    "longitude": -74.006,
    "city": "New York",
    "country": "US",
    "timezone": -18000
  },
  "units": "metric",
  "forecast_period": "6-day forecast",
  "retrieved_at": "2025-12-25T05:01:20.441Z",
  "data_points": 40,
  "daily_forecast": [
    {
      "date": "2025-12-25",
      "temperature": {
        "min": 2,
        "max": 6,
        "average": 4.2,
        "unit": "°C"
      },
      "feels_like": {
        "day": -1,
        "night": -3
      },
      "humidity": 60,
      "pressure": 1017,
      "weather": {
        "main": "Clouds",
        "description": "overcast clouds"
      },
      "wind": {
        "speed": 5.5,
        "direction": 280
      },
      "precipitation": {
        "probability": 0,
        "amount": 0
      },
      "clouds": 100,
      "visibility": 10000
    }
    // ... more days
  ]
}
```

***

### 🚀 Getting Started

#### Prerequisites

1. **Get a FREE API Key** from [OpenWeatherMap](https://openweathermap.org/api)
   - Sign up for a free account
   - Navigate to API Keys section
   - Copy your API key
   - **Wait 10-15 minutes** for activation

2. **Choose your method:**
   - Option A: Run on Apify Platform (easiest)
   - Option B: Run locally with Node.js
   - Option C: Run with Docker

***

### 📦 Installation & Usage

#### Option A: Running on Apify Platform (Recommended)

1. Visit [Apify Console](https://console.apify.com)
2. Create a new Actor or search for "Weather Forecast GPS"
3. Provide your input:
   ```json
   {
     "latitude": 40.7128,
     "longitude": -74.0060,
     "units": "metric",
     "apiKey": "your_api_key_here"
   }
   ```
4. Click "Start" and collect results from the dataset

**Advantages:** No setup, runs in cloud, always available

***

#### Option B: Running Locally with Node.js

```bash
## 1. Clone or download this repository
cd weather-forecast-actor

## 2. Install dependencies
npm install

## 3. Build the project
npm run build

## 4. Create input file
## Create storage/key_value_stores/default/INPUT.json with:
{
  "latitude": 40.7128,
  "longitude": -74.0060,
  "units": "metric",
  "apiKey": "your_openweathermap_api_key"
}

## 5. Run with Apify CLI
npx apify run

## 6. View output
cat storage/datasets/default/000000001.json
```

**Advantages:** Fast iteration, easy debugging, no internet required for code changes

***

#### Option C: Running with Docker

```bash
## 1. Start Docker Desktop application

## 2. Navigate to project directory
cd weather-forecast-actor

## 3. Build Docker image
docker build -t weather-forecast-actor .

## 4. Run the container
docker run --rm -v ${PWD}/storage:/actor/storage weather-forecast-actor

## 5. View output
cat storage/datasets/default/000000001.json
```

**Advantages:** Exact production environment, isolated dependencies, reproducible builds

***

#### Quick Test (Any Method)

After running, you should see:

```
✅ Success! Retrieved 6-day forecast for New York
```

And your output file will contain rich weather data like:

```json
{
  "location": {
    "city": "New York",
    "country": "US"
  },
  "daily_forecast": [
    {
      "date": "2025-12-25",
      "temperature": {
        "min": 2,
        "max": 6,
        "average": 4.2,
        "unit": "°C"
      },
      "weather": {
        "main": "Clouds",
        "description": "overcast clouds"
      }
    }
  ]
}
```

***

### 🌍 Finding GPS Coordinates

#### Quick Methods

- **Google Maps**: Right-click any location → Click the coordinates
- **Current Location**: Use browser's geolocation API
- **Address Lookup**: [LatLong.net](https://www.latlong.net/)

#### Popular Locations

| City | Latitude | Longitude |
|------|----------|-----------|
| New York, USA | 40.7128 | -74.0060 |
| London, UK | 51.5074 | -0.1278 |
| Tokyo, Japan | 35.6762 | 139.6503 |
| Paris, France | 48.8566 | 2.3522 |
| Sydney, Australia | -33.8688 | 151.2093 |
| Dubai, UAE | 25.2048 | 55.2708 |
| São Paulo, Brazil | -23.5505 | -46.6333 |

***

### 🔑 Getting an API Key

This Actor uses the OpenWeatherMap API:

1. Visit [OpenWeatherMap](https://openweathermap.org/api)
2. Sign up for a **free account**
3. Navigate to **API Keys** section
4. Copy your API key
5. **Wait 10-15 minutes** for activation

**Free tier includes:**

- 60 calls per minute
- 1,000,000 calls per month
- Perfect for most use cases!

***

### 📊 Output Data Schema

#### Location Object

- `latitude`, `longitude` - Input coordinates
- `city`, `country` - Resolved location names
- `timezone` - UTC offset in seconds

#### Daily Forecast Object

- `date` - ISO date string (YYYY-MM-DD)
- `temperature` - Min, max, average temps with unit
- `feels_like` - Day and night apparent temperature
- `humidity` - Average relative humidity (%)
- `pressure` - Average atmospheric pressure (hPa)
- `weather` - Main condition and description
- `wind` - Speed and direction
- `precipitation` - Probability (%) and amount (mm)
- `clouds` - Cloud coverage (%)
- `visibility` - Visibility distance (meters)

***

### 🎯 Use Cases

#### For Travelers ✈️

- Check weather before booking flights
- Plan clothing and gear for trips
- Avoid bad weather destinations

#### For Event Planners 🎪

- Schedule outdoor events with confidence
- Have backup plans for rain
- Optimize attendee comfort

#### For Developers 🤖

- Integrate weather into apps
- Build AI agents with weather awareness
- Create automated weather alerts

#### For Data Analysis 📈

- Collect weather patterns over time
- Correlate weather with business metrics
- Build predictive models

***

### 🏗️ Technical Stack

- **Runtime**: Node.js 20+
- **Language**: TypeScript 5.3
- **Framework**: Apify SDK 3.2
- **HTTP Client**: Axios
- **Data Source**: OpenWeatherMap API
- **Deployment**: Docker containerized

***

### 🛠️ Development

#### Project Structure

```
weather-forecast-actor/
├── src/
│   └── main.ts              # Main Actor logic (430 lines)
├── .actor/
│   ├── actor.json           # Actor metadata
│   ├── input_schema.json    # Input validation
│   └── INPUT.json           # Local input (git-ignored)
├── storage/                 # Local storage (git-ignored)
│   ├── datasets/            # Output data
│   └── key_value_stores/    # Input data
├── dist/                    # Compiled JavaScript
├── package.json
├── tsconfig.json
├── Dockerfile
└── README.md
```

#### Available Scripts

```bash
npm run build      # Compile TypeScript
npm run start      # Run compiled code
npm run dev        # Run with ts-node
npm run lint       # Type-check code
npm run clean      # Remove dist folder
npm run rebuild    # Clean and build
```

#### Building for Production

```bash
## Clean build
npm run rebuild

## Test locally
npx apify run

## Test with Docker
docker build -t weather-forecast-actor .
docker run --rm -v ${PWD}/storage:/actor/storage weather-forecast-actor

## Deploy to Apify
apify login
apify push
```

***

### 🐳 Docker Commands

#### Build the image:

```bash
docker build -t weather-forecast-actor .
```

#### Run the container:

```bash
docker run --rm -v ${PWD}/storage:/actor/storage weather-forecast-actor
```

#### Run with custom input:

```bash
## Create input file first, then:
docker run --rm \
  -v ${PWD}/storage:/actor/storage \
  weather-forecast-actor
```

#### Debug inside container:

```bash
docker run -it --rm \
  -v ${PWD}/storage:/actor/storage \
  --entrypoint /bin/bash \
  weather-forecast-actor
```

#### List images:

```bash
docker images
```

#### Remove image:

```bash
docker rmi weather-forecast-actor
```

***

### 🔒 Error Handling

The Actor handles common errors gracefully:

- **Invalid API Key** (401): Clear message with activation instructions
- **Location Not Found** (404): Suggests checking coordinates
- **Rate Limit** (429): Advises waiting or upgrading
- **Network Errors**: Provides connectivity troubleshooting
- **Invalid Input**: Validates all parameters with helpful messages

***

### 🐛 Troubleshooting

#### Docker Issues

**"Docker daemon is not running"**

```bash
## Solution: Start Docker Desktop application
## Check if running:
docker ps
```

**"Cannot find the file specified" (Windows)**

```bash
## Solution: Ensure Docker Desktop is running
## Restart Docker Desktop if needed
```

**Build fails with npm errors**

```bash
## Solution: Clean build without cache
docker build --no-cache -t weather-forecast-actor .
```

**Container can't find INPUT.json**

```bash
## Solution: Ensure the file exists
ls storage/key_value_stores/default/INPUT.json

## Create the directory structure if missing:
mkdir -p storage/key_value_stores/default
```

#### Local Run Issues

**"Input is required"**

```bash
## Solution: Use npx apify run instead of npm start
npx apify run
```

**API Key errors**

```bash
## Solution: Wait 10-15 minutes after creating OpenWeatherMap account
## Check key status at: https://home.openweathermap.org/api_keys
```

**Module not found**

```bash
## Solution: Reinstall dependencies
rm -rf node_modules package-lock.json
npm install
npm run build
```

#### Network Issues

**"Failed to fetch weather data"**

```bash
## Test API directly:
curl "https://api.openweathermap.org/data/2.5/forecast?lat=40.7128&lon=-74.0060&appid=YOUR_KEY&units=metric"

## Check DNS:
nslookup api.openweathermap.org
```

***

### 🚀 Performance

- **Execution Time**: 1-3 seconds average
- **Memory Usage**: ~50MB
- **API Calls**: 1 per Actor run
- **Cost**: <$0.01 per execution on Apify platform

***

### 📝 API Rate Limits

#### Free Tier (OpenWeatherMap)

- **60 calls/minute**
- **1,000,000 calls/month**
- **3-hour forecast intervals**

#### Recommended Usage

- Cache results when possible
- Respect rate limits
- Consider upgrading for high-volume use

***

### 🤝 Contributing

Contributions are welcome! Ideas for enhancement:

- \[ ] Add more weather providers (Weather.com, AccuWeather)
- \[ ] Support for weather alerts and warnings
- \[ ] Historical weather data comparison
- \[ ] Batch processing for multiple locations
- \[ ] Weather-based recommendations
- \[ ] Air quality index integration
- \[ ] Multi-language support

***

### 📄 License

MIT License - feel free to use and modify!

***

### 🏆 Apify $1M Challenge

This Actor was built for the [Apify $1M Challenge](https://apify.com/challenge) - a global competition to build AI-powered data extraction and automation tools.

#### Categories

- ✈️ Travel
- 🤖 Automation
- 🔗 Integrations

***

### 📞 Support

- **Documentation**: [docs.apify.com](https://docs.apify.com)
- **Discord**: [Apify Community](https://discord.com/invite/jyEM2PRvMU)
- **OpenWeather**: [openweathermap.org/faq](https://openweathermap.org/faq)
- **Issues**: [GitHub Issues](https://github.com/nagaumamahesh/weather-forecast-actor/issues)

***

### 🙏 Acknowledgments

- Built with [Apify Platform](https://apify.com)
- Weather data from [OpenWeatherMap](https://openweathermap.org)
- Inspired by the developer community

***

**Made with ❤️ for the Apify $1M Challenge**

*Get started now: [Deploy this Actor](https://console.apify.com)*

# Actor input Schema

## `latitude` (type: `number`):

GPS latitude coordinate. Must be between -90 (South Pole) and 90 (North Pole). Example: New York = 40.7128

## `longitude` (type: `number`):

GPS longitude coordinate. Must be between -180 and 180. Example: New York = -74.0060

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

Choose temperature unit system. Metric uses Celsius, imperial uses Fahrenheit.

## `apiKey` (type: `string`):

Your OpenWeatherMap API key. Get a FREE key at https://openweathermap.org/api (allows 1M calls/month). New keys may take 10-15 minutes to activate.

## `outputFormat` (type: `string`):

Choose how you want the weather data formatted. 'detailed' includes all fields, 'simple' is flat structure for CSV/Excel, 'summary' is concise overview.

## Actor input object example

```json
{
  "latitude": 40.7128,
  "longitude": -74.006,
  "units": "metric",
  "outputFormat": "detailed"
}
```

# 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 = {
    "latitude": 40.7128,
    "longitude": -74.006
};

// Run the Actor and wait for it to finish
const run = await client.actor("aligned_sassafras/weather-forecast-actor").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 = {
    "latitude": 40.7128,
    "longitude": -74.006,
}

# Run the Actor and wait for it to finish
run = client.actor("aligned_sassafras/weather-forecast-actor").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 '{
  "latitude": 40.7128,
  "longitude": -74.006
}' |
apify call aligned_sassafras/weather-forecast-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Weather Forecast Actor",
        "version": "0.0",
        "x-build-id": "Cq8nXcZ8ZbKrDYw7X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aligned_sassafras~weather-forecast-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aligned_sassafras-weather-forecast-actor",
                "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/aligned_sassafras~weather-forecast-actor/runs": {
            "post": {
                "operationId": "runs-sync-aligned_sassafras-weather-forecast-actor",
                "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/aligned_sassafras~weather-forecast-actor/run-sync": {
            "post": {
                "operationId": "run-sync-aligned_sassafras-weather-forecast-actor",
                "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": [
                    "latitude",
                    "longitude",
                    "apiKey"
                ],
                "properties": {
                    "latitude": {
                        "title": "Latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "GPS latitude coordinate. Must be between -90 (South Pole) and 90 (North Pole). Example: New York = 40.7128"
                    },
                    "longitude": {
                        "title": "Longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "GPS longitude coordinate. Must be between -180 and 180. Example: New York = -74.0060"
                    },
                    "units": {
                        "title": "Temperature Units",
                        "enum": [
                            "metric",
                            "imperial"
                        ],
                        "type": "string",
                        "description": "Choose temperature unit system. Metric uses Celsius, imperial uses Fahrenheit.",
                        "default": "metric"
                    },
                    "apiKey": {
                        "title": "OpenWeatherMap API Key",
                        "type": "string",
                        "description": "Your OpenWeatherMap API key. Get a FREE key at https://openweathermap.org/api (allows 1M calls/month). New keys may take 10-15 minutes to activate."
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "detailed",
                            "simple",
                            "summary"
                        ],
                        "type": "string",
                        "description": "Choose how you want the weather data formatted. 'detailed' includes all fields, 'simple' is flat structure for CSV/Excel, 'summary' is concise overview.",
                        "default": "detailed"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```