# Simply Recipes Scraper | Home Cooking Recipes (`parseforge/simplyrecipes-scraper`) Actor

Extract recipes from Simply Recipes with ingredients, method steps, prep and cook times, servings, ratings, author, and nutrition data. Search by cuisine or category to power recipe apps, meal planners, food blogs, and culinary machine learning projects at scale.

- **URL**: https://apify.com/parseforge/simplyrecipes-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Marketing, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🍳 Simply Recipes Scraper

> 🚀 **Export Simply Recipes data in seconds.** Search by keyword and get full recipe details - ingredients, step-by-step instructions, nutrition facts, ratings, and more. No login required.

> 🕒 **Last updated:** 2026-05-22 · **📊 19 fields** per record · **Unlimited recipes** · **Global coverage**

Simply Recipes is one of the most trusted recipe sites on the internet, with thousands of rigorously tested recipes across every cuisine and dietary need. This actor lets you extract structured recipe data at scale - from a single pasta dish to an entire category of weeknight dinners.

All data is sourced from Simply Recipes' structured JSON-LD markup, ensuring high accuracy on every field: ingredients, cook times, nutrition, and author attribution are pulled directly from the recipe schema on each page.

### Coverage

- **Thousands** of recipes across all categories: dinners, breakfasts, salads, desserts, drinks, and more
- **19 fields** per record including full ingredients list, step-by-step instructions, and per-serving nutrition
- **Search by keyword** - find any recipe by ingredient, dish name, or cuisine style
- **Paginated scraping** - automatically collects across multiple result pages to hit your `maxItems` target

### Target Audience / Use Cases

| Audience | Use Case |
|---|---|
| Food bloggers | Research trending recipes and identify content gaps |
| Nutrition researchers | Collect calorie and macro data across recipe categories |
| Meal planning apps | Build searchable recipe databases with full ingredient lists |
| Data scientists | Train food classification or NLP models |
| Recipe aggregators | Power multi-source recipe search engines |
| Home cooks | Bulk export recipes for personal meal planning spreadsheets |

### 📋 What the Simply Recipes Scraper does

- Searches Simply Recipes for any keyword (e.g. "pasta", "chicken soup", "vegan dessert")
- Paginates through search results automatically
- Visits each recipe page and extracts full structured data from JSON-LD
- Returns clean, structured JSON with 19 fields per recipe
- Enforces `maxItems` so you get exactly the number of recipes you need
- Handles pagination gaps and missing fields gracefully - no broken records

> 💡 **Why it matters:** Recipe data from Simply Recipes is among the most reliable on the internet. Every recipe is tested by their editorial team, meaning your dataset won't be full of crowd-sourced guesses. This scraper gives you that editorial quality at machine scale.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchQuery` | string | Yes | `pasta` | Keyword to search for (e.g. "chicken soup", "vegan cake") |
| `maxItems` | integer | No | `10` | Max recipes to return (free: 10, paid: up to 1,000,000) |

**Example - search for pasta recipes:**

```json
{
  "searchQuery": "pasta",
  "maxItems": 50
}
````

**Example - search for vegan desserts:**

```json
{
  "searchQuery": "vegan dessert",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** Free users are automatically limited to 10 recipes per run. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to scrape up to 1,000,000 recipes per run.

### 📊 Output

Each record contains 19 fields. Here is the full schema:

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | URL of the recipe's hero image |
| 📝 `title` | string | Recipe title |
| 👤 `author` | string | Recipe author name(s) |
| 🔗 `url` | string | Canonical URL of the recipe page |
| ⭐ `rating` | number | Average rating (e.g. 4.8) |
| 🗳️ `numRatings` | integer | Number of ratings |
| ⏱️ `prepTime` | string | Preparation time (e.g. "10 min") |
| 🍳 `cookTime` | string | Cook time (e.g. "20 min") |
| ⏰ `totalTime` | string | Total time from start to finish |
| 🍽️ `servings` | string | Number of servings |
| 🔥 `calories` | integer | Calories per serving |
| 🥗 `ingredients` | array | Full list of ingredients with quantities |
| 📋 `instructions` | array | Step-by-step cooking instructions |
| 📄 `description` | string | Recipe description / intro paragraph |
| 🏷️ `tags` | array | Keywords and categories (e.g. "Italian", "Quick and Easy") |
| 🌍 `cuisine` | string | Cuisine type (e.g. "Italian", "American") |
| 🥦 `diet` | array | Dietary labels detected (Vegan, Vegetarian, Gluten-Free, etc.) |
| 🕐 `scrapedAt` | string | ISO timestamp of when the record was scraped |
| ❌ `error` | string | Error message if extraction failed, otherwise null |

**Sample record:**

```json
{
  "imageUrl": "https://www.simplyrecipes.com/thmb/0UeN5LhKq-ze3BcZJ7_Yp803T24=/1500x0/filters:no_upscale():max_bytes(150000):strip_icc()/Simply-Pasta-Carbonara-LEAD-1-c477cc25c7294cd9a3fc51ece176481f.jpg",
  "title": "Pasta Carbonara",
  "author": "Elise Bauer",
  "url": "https://www.simplyrecipes.com/recipes/spaghetti_alla_carbonara/",
  "rating": 4.8,
  "numRatings": 48,
  "prepTime": "10 min",
  "cookTime": "20 min",
  "totalTime": "30 min",
  "servings": "6",
  "calories": 359,
  "ingredients": [
    "1 tablespoon extra virgin olive oil or unsalted butter",
    "1/2 pound pancetta or thick cut bacon, diced",
    "1-2 garlic cloves, minced, about 1 teaspoon (optional)",
    "3-4 whole eggs",
    "1 cup grated parmesan or pecorino cheese",
    "1 pound spaghetti (or bucatini or fettuccine)",
    "Salt and black pepper to taste"
  ],
  "instructions": [
    "Put a large pot of salted water on to boil (1 tablespoon salt for every 2 quarts of water.)",
    "While the water is coming to a boil, heat the olive oil or butter in a large saute pan over medium heat. Add the bacon or pancetta and cook slowly until crispy...",
    "In a small bowl, beat the eggs and mix in about half of the cheese.",
    "Once the water has reached a rolling boil, add the dry pasta, and cook, uncovered, at a rolling boil.",
    "When the pasta is al dente, use tongs to move it to the bowl with the bacon and garlic...",
    "Add the beaten eggs with cheese and toss quickly to combine once more."
  ],
  "description": "Classic spaghetti carbonara is an indulgent yet surprisingly simple recipe. Made with pancetta (or bacon) and plenty of Parmesan cheese, our foolproof recipe takes just 30 minutes to prepare from start to finish.",
  "tags": ["Quick and Easy", "Restaurant Favorite", "Bacon", "Carbonara", "Egg", "Italian", "Pancetta", "Parmesan", "Pasta", "Spaghetti"],
  "cuisine": "Italian",
  "diet": null,
  "scrapedAt": "2026-05-22T01:34:38.158Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🎯 JSON-LD extraction | Gets data from structured schema markup - more reliable than HTML scraping |
| 🔍 Keyword search | Find any recipe type, ingredient, or cuisine |
| 📦 Full ingredient lists | Every ingredient with precise quantities |
| 📋 Step-by-step instructions | All cooking steps in order, ready to parse or display |
| 🔥 Nutrition data | Per-serving calories for every recipe that has it |
| ⭐ Ratings and reviews | Aggregate rating and count from real user reviews |
| 🏷️ Tags and categories | Pre-classified by cuisine, diet, and meal type |
| 🚀 Fast and lightweight | No browser required - pure HTTP fetching for maximum speed |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Browser-based actors |
|---|---|---|---|
| Speed | Fast (HTTP) | Slow | Slow |
| JSON-LD extraction | Yes | Requires custom code | Varies |
| Pagination | Automatic | Manual | Varies |
| Ingredient lists | Full | Varies | Varies |
| Nutrition data | Yes | Varies | Varies |
| Maintenance | Managed | Self-maintained | Varies |

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (includes $5 free credit)
2. Open the Simply Recipes Scraper on Apify Store
3. Enter your search keyword in the `searchQuery` field
4. Set `maxItems` to control how many recipes to collect
5. Click **Start** and wait for the run to finish (typically seconds to minutes)
6. Download your dataset as JSON, CSV, Excel, or XML

### 💼 Business use cases

#### Meal planning and nutrition apps

Build a searchable recipe database with complete ingredient lists and per-serving nutrition data. Use the `calories`, `ingredients`, and `servings` fields to power a meal planning calculator or food diary feature.

#### Food content and SEO research

Identify which recipe categories perform well and what keywords Simply Recipes ranks for. Use `tags`, `cuisine`, and `title` to map content gaps and inform your editorial calendar.

#### Recipe AI and NLP training

Train ingredient-parsing models, recipe summarizers, or cuisine classifiers using the full structured text from `ingredients`, `instructions`, and `description`. Real editorial data is far more reliable than crowd-sourced content.

#### Restaurant and catering menus

Use the structured ingredient and timing data to estimate prep times, scale recipes for large groups, or build cost estimation tools based on ingredient quantities.

### 🔌 Automating Simply Recipes Scraper

Connect this actor to automation platforms to build scheduled data pipelines:

- **Make (Integromat)** - Trigger on a schedule and push new recipes to Google Sheets or Airtable
- **Zapier** - Connect to Slack or email to receive daily recipe alerts by keyword
- **n8n** - Build complex recipe processing workflows with branching logic
- **Apify API** - Call the actor from any codebase and process results programmatically

### 🌟 Beyond business use cases

#### Home cooking and meal prep

Export a week of dinner recipes in one run, then load into a spreadsheet with shopping list columns. Filter by `calories` and `totalTime` to fit your schedule.

#### Academic food research

Collect large corpora of recipe text for computational gastronomy, ingredient co-occurrence analysis, or cuisine clustering studies.

#### Non-profit nutrition education

Build free tools that help community members find tested, reliable recipes by dietary restriction or ingredient availability.

#### Personal projects

Power a recipe recommendation bot, build a personal meal planner, or create a voice assistant skill that reads recipe steps aloud.

### 🤖 Ask an AI assistant about this scraper

You can ask ChatGPT, Claude, or any AI assistant:

> "I have a JSON dataset of recipes from Simply Recipes with fields: imageUrl, title, author, url, rating, numRatings, prepTime, cookTime, totalTime, servings, calories, ingredients, instructions, description, tags, cuisine, diet, scrapedAt. Help me filter by cuisine, sort by rating, and export to a meal plan spreadsheet."

The structured output from this actor is designed to work seamlessly with AI-powered data analysis.

### ❓ Frequently Asked Questions

#### ❓ Does this require a Simply Recipes account?

No. All data is publicly accessible without login.

#### ❓ How many recipes can I scrape?

Free users are limited to 10 per run. Paid users can scrape up to 1,000,000 recipes per run.

#### ❓ How do I search for a specific cuisine?

Enter the cuisine name as your search keyword - e.g. "Italian pasta", "Mexican chicken", or "Thai noodles".

#### ❓ Does the scraper get the full ingredient list?

Yes. All ingredients with their quantities are extracted from the JSON-LD schema on each recipe page.

#### ❓ Does it get step-by-step instructions?

Yes. All cooking steps are extracted in order and returned as an array of strings.

#### ❓ What nutrition fields are available?

Currently the scraper extracts calories per serving. Additional nutrition fields (carbs, protein, fat) are available on the page and can be added on request.

#### ❓ Can I search by category instead of keyword?

The `searchQuery` field searches Simply Recipes' full-text search, so category names like "dessert", "breakfast", or "salad" work well as search terms.

#### ❓ How fresh is the data?

The scraper fetches live data in real-time from Simply Recipes. Every run gets the latest recipes and ratings.

#### ❓ What happens if a recipe page fails to load?

The actor returns a record with the `url` and an `error` field describing the failure. Other recipes in the batch are not affected.

#### ❓ Can I export the data to Excel or Google Sheets?

Yes. Apify datasets support one-click export to JSON, CSV, Excel, XML, and RSS. Use the Apify API or UI to download in your preferred format.

#### ❓ Is the actor updated when Simply Recipes changes their site?

ParseForge monitors actor health. If the site structure changes and data extraction breaks, the actor is updated promptly.

#### ❓ Can I get more than 1,000,000 recipes?

Contact ParseForge via the Apify Actor page for enterprise volume requirements.

### 🔌 Integrate with any app

This actor works with any tool that can read JSON or call an HTTP API:

- **Google Sheets** - Import via Apify's Google Sheets integration or CSV export
- **Airtable** - Use Apify's Airtable integration or the API
- **Notion** - Import via CSV or use Zapier/Make to sync automatically
- **Slack** - Get recipe notifications via Zapier or Make workflows
- **Python / R** - Hit the Apify dataset API directly for data science workflows
- **Node.js / TypeScript** - Use the Apify client SDK for programmatic access
- **Power BI / Tableau** - Connect via the Apify dataset REST API
- **Webhook** - Trigger any downstream system when a run completes

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [AllRecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) | Scrape recipes from AllRecipes with ratings and user reviews |
| [Epicurious Scraper](https://apify.com/parseforge/epicurious-scraper) | Extract Epicurious recipes with full professional recipe details |
| [Food.com Scraper](https://apify.com/parseforge/food-com-scraper) | Get crowd-sourced recipes from Food.com with community ratings |
| [Serious Eats Scraper](https://apify.com/parseforge/seriouseats-scraper) | Scrape Serious Eats for deeply tested, technique-focused recipes |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data scrapers across food, travel, real estate, and finance.

***

**Disclaimer:** This actor is not affiliated with, endorsed by, or connected to Simply Recipes or Dotdash Meredith. It accesses only publicly available data. Users are responsible for ensuring their use of this data complies with Simply Recipes' Terms of Service and applicable laws.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search for recipes (e.g. 'pasta', 'chicken soup', 'chocolate cake').

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "searchQuery": "pasta",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "pasta",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/simplyrecipes-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 = {
    "searchQuery": "pasta",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/simplyrecipes-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 '{
  "searchQuery": "pasta",
  "maxItems": 10
}' |
apify call parseforge/simplyrecipes-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Simply Recipes Scraper | Home Cooking Recipes",
        "description": "Extract recipes from Simply Recipes with ingredients, method steps, prep and cook times, servings, ratings, author, and nutrition data. Search by cuisine or category to power recipe apps, meal planners, food blogs, and culinary machine learning projects at scale.",
        "version": "0.0",
        "x-build-id": "LPeyG9TeOsP6Nu85b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~simplyrecipes-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-simplyrecipes-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/parseforge~simplyrecipes-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-simplyrecipes-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/parseforge~simplyrecipes-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-simplyrecipes-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for recipes (e.g. 'pasta', 'chicken soup', 'chocolate cake')."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
