# BBC Good Food Scraper | Recipes and Cooking Data (`parseforge/bbcgoodfood-scraper`) Actor

Extract recipes from BBC Good Food including ingredients, method steps, prep and cook times, servings, difficulty, nutrition, ratings, and reviews. Search by cuisine, diet, occasion, or ingredient to build culinary datasets, meal plans, recipe apps, or AI training corpora.

- **URL**: https://apify.com/parseforge/bbcgoodfood-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)

## 🍳 BBC Good Food Recipe Scraper

> 🚀 **Export BBC Good Food recipes to CSV, Excel, or JSON in seconds.** No account needed, no coding required.

> 🕒 **Last updated:** 2026-05-22 · **📊 19 fields** per record · **1,700+ results per search** · **Global coverage**

Extract recipes from BBC Good Food with complete data: ingredients, cooking times, difficulty, ratings, nutrition info, dietary tags, and more. Whether you're building a meal planner, training a recipe AI, or researching culinary trends - this scraper delivers clean, structured data instantly.

BBC Good Food is one of the world's largest recipe databases with over 13,000 professionally tested recipes covering every cuisine, diet, and skill level.

**Coverage:** Recipes for every occasion - weeknight dinners, weekend baking, holiday feasts, quick lunches - filtered by keyword, diet, cuisine, or difficulty. Up to 30 results per search page, paginated to your `maxItems` limit.

| Who uses this | Why |
|---|---|
| Food tech startups | Dataset for recipe recommendation engines |
| Nutritionists | Calorie and ingredient analysis at scale |
| Home cooks | Build personal recipe collections |
| Data journalists | Food trend research |
| AI trainers | Fine-tuning recipe generation models |
| Meal kit companies | Competitor recipe research |

### 📋 What the BBC Good Food Scraper does

- Searches BBC Good Food by keyword, diet, cuisine, or difficulty level
- Fetches full recipe detail pages for each result
- Extracts all structured data from Next.js page state and JSON-LD schema
- Produces clean records with 19 fields per recipe
- Respects rate limits with automatic paging and delays
- Auto-limits to 10 items for free users, up to 1,000,000 for paid plans

> 💡 **Why it matters:** BBC Good Food's recipes are professionally tested and editorially curated - this is not user-generated content. The data is research-grade: every recipe has been made, tasted, and rated by real cooks.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `maxItems` | integer | No | 10 | Maximum number of recipes to collect (free: 10, paid: up to 1,000,000) |
| `searchQuery` | string | No | pasta | Keyword to search for recipes |
| `diet` | enum | No | - | Dietary filter (vegetarian, vegan, gluten-free, etc.) |
| `difficulty` | enum | No | - | Difficulty filter (Easy, More effort, A challenge) |
| `cuisine` | string | No | - | Cuisine filter (italian, indian, british, etc.) |

**Simple keyword search:**
```json
{
  "searchQuery": "chocolate cake",
  "maxItems": 50
}
````

**Filtered search (vegan + easy):**

```json
{
  "searchQuery": "soup",
  "diet": "vegan",
  "difficulty": "easy",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** BBC Good Food returns up to 30 recipes per search page. The scraper automatically paginates to collect your requested number of items. Diet and difficulty filters apply server-side so you get genuinely filtered results.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼 `imageUrl` | string | Main recipe image URL |
| 📌 `title` | string | Recipe title |
| 📝 `description` | string | Recipe introduction |
| ⭐ `rating` | number | Average star rating (e.g. 4.75) |
| 💬 `reviewCount` | number | Number of user ratings |
| 👤 `author` | string | Recipe author name |
| 🎯 `difficulty` | string | Easy / More effort / A challenge |
| ⏱ `prepTime` | string | Preparation time (ISO 8601: PT30M) |
| 🍳 `cookTime` | string | Cooking time (ISO 8601: PT45M) |
| ⏰ `totalTime` | string | Total time (ISO 8601: PT1H15M) |
| 🍽 `servings` | string | Number of servings |
| 🔥 `calories` | string | Calories per serving |
| 🥦 `ingredients` | array | List of ingredient strings |
| 🥗 `diet` | string | Dietary tags (e.g. Nut-free, High-protein) |
| 🌍 `cuisine` | string | Cuisine type (when available) |
| 🏷 `category` | string | Meal category (Dinner, Lunch, etc.) |
| 🔑 `keywords` | string | Recipe keywords/tags |
| 🔗 `url` | string | Source recipe URL |
| 🕒 `scrapedAt` | string | ISO timestamp of scrape |
| ❌ `error` | string | Error message (if scraping failed) |

**Sample record:**

```json
{
  "imageUrl": "https://images.immediate.co.uk/production/volatile/sites/30/2020/08/chicken_pasta_bake-06fe2d6.jpg?resize=440,400",
  "title": "Chicken pasta bake",
  "description": "Enjoy this gooey cheese and chicken pasta bake for the ultimate weekday family dinner. Serve straight from the dish with a dressed green salad",
  "rating": 4.6,
  "reviewCount": 1006,
  "author": "Esther Clark",
  "difficulty": "Easy",
  "prepTime": "PT30M",
  "cookTime": "PT45M",
  "totalTime": "PT1H15M",
  "servings": "6",
  "calories": "575 calories",
  "ingredients": [
    "4 tbsp olive oil",
    "1 onion finely chopped",
    "2 garlic cloves crushed",
    "¼ tsp chilli flakes",
    "2 x 400g cans chopped tomatoes",
    "1 tsp caster sugar",
    "6 tbsp mascarpone",
    "4 skinless chicken breasts, sliced into strips",
    "300g penne",
    "70g mature cheddar grated",
    "50g grated mozzarella",
    "½ small bunch of parsley finely chopped"
  ],
  "diet": "High-protein",
  "cuisine": null,
  "category": "Dinner, Main course, Pasta",
  "keywords": "Cheese, Chicken, Chicken pasta bake, Comfort Food, Esther Clark, Mascarpone, Mozzarella, Pasta, Pasta bake",
  "url": "https://www.bbcgoodfood.com/recipes/chicken-pasta-bake",
  "scrapedAt": "2026-05-22T00:49:45.378Z"
}
```

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🥇 Real data from source | Extracted directly from BBC Good Food's Next.js page state - not cached or stale |
| 🥦 Full ingredient lists | Every ingredient string, exactly as written by the recipe author |
| ⭐ Live ratings | Actual user rating averages and review counts at scrape time |
| 🎯 Difficulty + diet tags | Pulled from structured data, not guessed from keywords |
| 🔥 Nutrition data | Calories per serving plus fat, protein, carb breakdown in keywords |
| 🌍 Multi-filter search | Combine keyword + diet + difficulty + cuisine in one run |
| 💾 All export formats | Download as CSV, Excel, JSON, XML from the Apify dataset |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual copy-paste | Generic scraper |
|---|---|---|---|
| Structured ingredient list | Yes | No | Rarely |
| Live ratings | Yes | Yes | Sometimes |
| Difficulty level | Yes | Yes | No |
| Dietary tags | Yes | No | No |
| Nutrition info | Yes | Yes | No |
| Bulk export | Up to 1M | Not possible | Limited |
| Search + filter | Yes | Manual | No |

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (comes with $5 credit)
2. Open the [BBC Good Food Scraper](https://apify.com/parseforge/bbcgoodfood-scraper) on Apify Store
3. Enter your search query, optional filters, and `maxItems`
4. Click **Start** and wait a few seconds
5. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Meal planning apps

Build weekly meal plan generators powered by real recipes. Extract prep time, calories, servings, and ingredients to automatically generate shopping lists for any dietary preference.

#### Food delivery and recipe kits

Identify trending recipe styles - which cuisines are most popular, which ingredients appear most often, what difficulty levels attract the most ratings - to inform your menu development and marketing.

#### Nutritional research

Aggregate calorie and ingredient data across thousands of recipes to analyse dietary patterns, identify hidden allergens in popular dishes, or compare nutritional profiles by cuisine type.

#### AI and machine learning datasets

Build training datasets for recipe generation models, ingredient substitution AI, or dietary restriction recommendation systems - with structured, high-quality data from a trusted editorial source.

### 🔌 Automating BBC Good Food Scraper

Connect this actor to your workflows using Apify integrations:

- **Make (Integromat):** Trigger a recipe scrape on a schedule and push results to Google Sheets
- **Zapier:** Auto-populate a meal planning database when new recipes match your search
- **Slack:** Get a weekly digest of top-rated new recipes in a specific category
- **Airtable / Notion:** Sync your recipe database automatically

### 🌟 Beyond business use cases

#### Research and journalism

Track how recipe trends shift over time - which diets are gaining popularity, how calorie counts have changed in featured recipes, which cuisines are being championed.

#### Creative writing and cookbooks

Use the ingredient and method data as inspiration for your own recipe variations. The structured data makes it easy to identify flavour profiles and technique patterns.

#### Non-profit and education

Nutrition educators can build learning materials from real recipe data. Community organisations can identify affordable, healthy recipes that fit dietary restrictions.

#### Experimentation and personal projects

Build your own recipe search engine, a calorie calculator app, or a "what can I make with these ingredients" tool - all powered by real BBC Good Food data.

### 🤖 Ask an AI assistant about this scraper

You can use ChatGPT, Claude, or any AI assistant to help you analyse the output:

> "Here is a CSV of 500 BBC Good Food recipes. What are the 10 most common ingredients? Which difficulty level has the highest average rating? Which diet tags appear most often in high-calorie recipes?"

The structured data from this scraper is designed to be AI-ready.

### ❓ Frequently Asked Questions

#### Does this require a BBC Good Food account?

No. The scraper uses public recipe pages. No login or subscription is needed.

#### What is the `maxItems` limit?

Free users are capped at 10 items per run. [Paid plans](https://console.apify.com/sign-up?fpr=vmoqkp) allow up to 1,000,000 items per run.

#### How fast is it?

Each recipe takes roughly 300ms to scrape. 100 recipes takes about 30-45 seconds. The scraper respects rate limits to avoid being blocked.

#### Can I filter by multiple diets?

Currently one diet filter per run. To combine filters, run multiple times and merge the datasets.

#### What does the `diet` field contain?

The diet field shows tags from BBC Good Food's own editorial system - things like "Nut-free", "High-protein", "Vegetarian", "Vegan", "Gluten-free". Not every recipe has a diet tag.

#### Why is `cuisine` sometimes null?

BBC Good Food only assigns a cuisine to certain recipes. Many classic British dishes and fusion recipes don't carry a cuisine tag. This is accurate to the source.

#### Are ingredients structured or free text?

Ingredients are returned exactly as written by the author - e.g. "300g penne" or "2 garlic cloves, crushed". They are stored as a JSON array of strings.

#### What do the ISO time formats mean?

Times use ISO 8601 duration format: PT30M = 30 minutes, PT1H15M = 1 hour 15 minutes. You can parse these with any date library.

#### Does the scraper handle pagination?

Yes. It automatically pages through search results until it reaches your `maxItems` count, requesting new pages only as needed.

#### Can I scrape without a search query?

Yes. If no `searchQuery` is provided, the scraper defaults to "pasta" as a seed search. Specify your own query for targeted results.

#### Is this data real-time?

Yes. Every run fetches live data from the BBC Good Food website. Ratings, review counts, and content reflect the current state of each recipe page.

#### How do I export to Excel?

In the Apify dataset view, click **Export** and choose XLSX. All fields including the ingredient array will be included.

### 🔌 Integrate with any app

CSV, Excel, JSON, XML, RSS via Apify dataset export - Google Sheets via Apify integration - Make (Integromat) - Zapier - Slack - Airtable - Notion - MongoDB - PostgreSQL - BigQuery - REST API via Apify dataset endpoints

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Allrecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) | Scrape Allrecipes.com with user ratings and reviews |
| [Seriouseats Scraper](https://apify.com/parseforge/seriouseats-scraper) | Extract serious culinary recipes with detailed technique notes |
| [Epicurious Scraper](https://apify.com/parseforge/epicurious-scraper) | Scrape Epicurious recipes with Bon Appetit-quality data |

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

***

**Disclaimer:** This actor is not affiliated with, endorsed by, or connected to BBC Good Food or Immediate Media. It accesses publicly available recipe pages for research and educational purposes. Use responsibly and in accordance with BBC Good Food's terms of service.

# Actor input Schema

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

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

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

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

## `diet` (type: `string`):

Filter by dietary requirement

## `difficulty` (type: `string`):

Filter by recipe difficulty

## `cuisine` (type: `string`):

Filter by cuisine type (e.g. italian, indian, british)

## Actor input object example

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

# 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 = {
    "maxItems": 10,
    "searchQuery": "pasta"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BBC Good Food Scraper | Recipes and Cooking Data",
        "description": "Extract recipes from BBC Good Food including ingredients, method steps, prep and cook times, servings, difficulty, nutrition, ratings, and reviews. Search by cuisine, diet, occasion, or ingredient to build culinary datasets, meal plans, recipe apps, or AI training corpora.",
        "version": "0.1",
        "x-build-id": "bNmeiAcaPjUieajOZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~bbcgoodfood-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-bbcgoodfood-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~bbcgoodfood-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-bbcgoodfood-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~bbcgoodfood-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-bbcgoodfood-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "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"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for recipes (e.g. pasta, chicken, chocolate cake)"
                    },
                    "diet": {
                        "title": "Diet",
                        "enum": [
                            "vegetarian",
                            "vegan",
                            "gluten-free",
                            "dairy-free",
                            "nut-free",
                            "healthy",
                            "egg-free",
                            "low-sugar",
                            "high-fibre",
                            "high-protein",
                            "low-calorie",
                            "low-fat",
                            "keto",
                            "low-carb"
                        ],
                        "type": "string",
                        "description": "Filter by dietary requirement"
                    },
                    "difficulty": {
                        "title": "Difficulty",
                        "enum": [
                            "easy",
                            "more-effort",
                            "a-challenge"
                        ],
                        "type": "string",
                        "description": "Filter by recipe difficulty"
                    },
                    "cuisine": {
                        "title": "Cuisine",
                        "type": "string",
                        "description": "Filter by cuisine type (e.g. italian, indian, british)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```