# Recipe Scraper (Universal / schema.org) (`crawlerbros/recipe-scraper`) Actor

Scrape any schema.org-compliant recipe site like Epicurious, BBC Good Food, Tasty, NYT Cooking, Serious Eats, Food Network, plus thousands of food blogs. Extracts ingredients, instructions, nutrition, ratings, prep/cook time, yield, author, and images via JSON-LD parsing.

- **URL**: https://apify.com/crawlerbros/recipe-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Recipe Scraper (Universal / schema.org)

Scrape **any schema.org-compliant recipe site**. Extracts ingredients, step-by-step instructions, nutrition, ratings, prep + cook + total time, yield, author, images, and video URLs from a clean schema.org/Recipe JSON-LD parse.

Works on **Epicurious**, **Tasty**, **BBC Good Food**, **NYT Cooking**, **Bon Appétit**, **Serious Eats**, **King Arthur Baking**, **Food Network**, **Smitten Kitchen**, **Budget Bytes**, and **thousands of food blogs** that use the standard recipe schema (most WordPress recipe plugins emit it).

> **AllRecipes is not supported.** It is fronted by Akamai Bot Manager which blocks both datacenter and residential IPs. AllRecipes URLs are rejected upfront with a typed `url_failed` (`reason: "unsupported_site"`) record. Use any of the supported sites above instead.

### What you get

#### Recipe records (`recordType=recipe`)

| Field | Description |
| --- | --- |
| `url` | Canonical recipe URL |
| `id` | Same as `url` |
| `platform` | Site slug (`epicurious`, `tasty`, `bbcgoodfood`, `nytcooking`, `bonappetit`, `seriouseats`, …) |
| `name` | Recipe title |
| `description` | Short blurb (HTML stripped) |
| `image` | Hero image URL |
| `author` | `{name, [url]}` |
| `ratingValue` | Average rating 0-5 |
| `ratingCount` | Number of ratings |
| `reviewCount` | Number of written reviews |
| `prepTimeMinutes` | Prep time in minutes |
| `cookTimeMinutes` | Cook time in minutes |
| `totalTimeMinutes` | Total time (uses `totalTime` if present, else `prep + cook`) |
| `recipeYield` | Servings / pieces (e.g. `8 slices`) |
| `recipeCategory` | Array (e.g. `["Dessert"]`) |
| `recipeCuisine` | Array (e.g. `["American"]`) |
| `keywords` | Array of free-form keyword tags |
| `recipeIngredient` | Array of ingredient strings |
| `recipeInstructions` | Array of step strings |
| `nutrition` | `{calories, proteinContent, carbohydrateContent, fatContent, sodiumContent, …}` |
| `video` | `{url, name, thumbnailUrl}` if present |
| `datePublished` | ISO publish date |
| `dateModified` | ISO last-modified date |
| `scrapedAt` | ISO 8601 UTC timestamp |

Empty fields are dropped from every record at every depth.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | Enum | `byUrls` | `byUrls` / `byTag` / `bySitemap` |
| `recipeUrls` | Array | `["https://www.epicurious.com/recipes/food/views/banana-bread"]` | Recipe URLs (mode=byUrls) |
| `tagUrls` | Array | — | Epicurious tag URLs or slugs (mode=byTag) — e.g. `dessert`, `/ingredient/banana`, full category URL |
| `sitemapUrls` | Array | — | Sitemap.xml URLs from any recipe site (mode=bySitemap) |
| `minRating` | Integer | — | Drop recipes with `ratingValue` below this. Scale 0-500 (e.g. 400 = 4.0/5) |
| `minRatingCount` | Integer | — | Drop recipes with fewer ratings than this |
| `maxTotalTimeMinutes` | Integer | — | Drop recipes with total time above this |
| `keywordIncludes` | String | — | Drop recipes whose `name + description` don't include this keyword |

#### Example input — by tag (Epicurious)

```json
{
  "mode": "byTag",
  "tagUrls": ["main-course", "/ingredient/banana"],
  "maxItems": 30
}
````

#### Example input — by sitemap (BBC Good Food)

```json
{
  "mode": "bySitemap",
  "sitemapUrls": ["https://www.bbcgoodfood.com/sitemaps/2026-Q2-recipe.xml"],
  "maxItems": 50
}
```

| `proxy` | Object | RESIDENTIAL | Optional; supported sites work without proxy too |
| `maxItems` | Integer | `50` | Hard cap on emitted records (1-1000) |

#### Example input — single Epicurious recipe (no proxy needed)

```json
{
  "recipeUrls": ["https://www.epicurious.com/recipes/food/views/banana-bread"]
}
```

#### Example input — bulk recipe URLs across multiple sites

```json
{
  "recipeUrls": [
    "https://tasty.co/recipe/banana-bread",
    "https://www.bbcgoodfood.com/recipes/banana-bread",
    "https://cooking.nytimes.com/recipes/12166-banana-bread",
    "https://www.epicurious.com/recipes/food/views/banana-bread"
  ],
  "minRating": 400,
  "maxTotalTimeMinutes": 90
}
```

#### Example input — keyword filter

```json
{
  "recipeUrls": ["https://tasty.co/recipe/banana-bread"],
  "keywordIncludes": "banana",
  "minRatingCount": 100
}
```

### Example output

```json
{
  "recordType": "recipe",
  "url": "https://www.epicurious.com/recipes/food/views/banana-bread",
  "platform": "epicurious",
  "name": "Banana Bread With Variations",
  "description": "Use this versatile banana bread recipe as a base for fun mix-ins...",
  "image": "https://assets.epicurious.com/photos/.../banana-bread.jpg",
  "author": { "name": "Epicurious Editors" },
  "ratingValue": 4.5,
  "ratingCount": 423,
  "prepTimeMinutes": 15,
  "cookTimeMinutes": 60,
  "totalTimeMinutes": 75,
  "recipeYield": "1 loaf",
  "recipeCategory": ["dessert"],
  "recipeCuisine": ["American"],
  "keywords": ["banana", "bread", "baking"],
  "recipeIngredient": [
    "1¾ cups all-purpose flour",
    "3 large overripe bananas, mashed",
    "..."
  ],
  "recipeInstructions": [
    "Preheat oven to 350°F.",
    "In a bowl, mash the bananas...",
    "..."
  ],
  "nutrition": {
    "calories": "320",
    "carbohydrateContent": "55g",
    "proteinContent": "5g"
  },
  "datePublished": "2009-03-30",
  "scrapedAt": "2026-05-06T10:42:18Z"
}
```

### Use cases

- **Recipe SEO / content audits** — Pull schema.org Recipe data across competitor sites for content gap analysis.
- **Meal-planning apps** — Build recipe libraries by ingesting curated URL lists.
- **Nutrition trackers** — Standardize ingredient + nutrition data across sources.
- **AI training data** — Construct labelled recipe datasets for ML pipelines (cooking instruction generation, ingredient extraction).
- **Aggregator backends** — Power recipe-bookmarking apps that index user-submitted URLs.

### FAQ

**Why isn't AllRecipes supported?**
AllRecipes is fronted by Akamai Bot Manager which blocks both datacenter and residential IP ranges aggressively. Every known bypass currently fails. AllRecipes URLs are rejected upfront with a typed `url_failed` (`reason: "unsupported_site"`) record so users see clear feedback instead of silent failures or fake data.

**Which sites are confirmed to work?**

- ✅ **Epicurious** — works without proxy
- ✅ **Tasty** (BuzzFeed) — works without proxy
- ✅ **BBC Good Food** — works without proxy
- ✅ **NYT Cooking** — works without proxy (paywall content blocked, public recipes work)
- ✅ **Bon Appétit, Serious Eats, Food Network, King Arthur Baking** — work, residential proxy is the safe default
- ✅ **Most WordPress food blogs** — work without proxy (Smitten Kitchen, Budget Bytes, Pinch of Yum, Minimalist Baker, etc.)
- ❌ **AllRecipes** — not supported (rejected upfront)

**What if a URL has no schema.org/Recipe JSON-LD?**
The actor emits a `url_failed` record with `reason: "no_recipe_jsonld"`. Most modern recipe sites embed it; sites that don't (older blogs, sites with custom layouts) won't yield data.

**Do I get instructions as a single block or step-by-step?**
Step-by-step. The actor parses `HowToStep` and `HowToSection` schema types into a flat array of step strings. HTML formatting is stripped.

**What if the page returns blocked / 403?**
The actor retries with exponential backoff. URLs that 403 emit a `url_failed` record with `reason: "anti_bot_block"`.

**How current is the data?**
Live — every run hits the recipe site at request time. Schedule the actor for daily / weekly refreshes to track rating drift on a recipe portfolio.

### Limitations

- The actor reads `schema.org/Recipe` JSON-LD only. Sites that don't embed it (or use a custom microformat) won't yield data.
- AllRecipes specifically requires residential proxy; without one you'll get a `recipe_blocked` sentinel.
- Some sites strip nutrition data or vary on `prepTime` / `cookTime`; missing fields are simply omitted.
- Per-comment / per-review data isn't included (only aggregate `ratingCount` / `reviewCount`).
- Video transcripts / step-by-step photos are not captured.

# Actor input Schema

## `mode` (type: `string`):

How to source recipe URLs.

## `recipeUrls` (type: `array`):

Recipe URLs from any schema.org-compliant site (Epicurious, BBC Good Food, Tasty, NYT Cooking, Bon Appétit, Serious Eats, Food Network, King Arthur Baking, food blogs, etc.). AllRecipes URLs are rejected as unsupported.

## `tagUrls` (type: `array`):

Epicurious tag/category URLs OR bare slugs. Examples: `https://www.epicurious.com/recipes/category/main-course`, `/ingredient/banana`, `dessert`. The actor scrapes the tag page → finds recipe URLs → fetches each.

## `sitemapUrls` (type: `array`):

Sitemap.xml URLs from any recipe site (e.g. `https://www.bbcgoodfood.com/sitemap.xml`, `https://www.epicurious.com/sitemap.xml`, or a deeper recipe-only sitemap). The actor walks the sitemap (one level deep into sitemap indexes), filters recipe-looking URLs, and runs them through the JSON-LD pipeline.

## `minRating` (type: `integer`):

Drop recipes with `ratingValue` below this. Scale 0-500 (e.g. 400 = 4.0/5).

## `minRatingCount` (type: `integer`):

Drop recipes with fewer than this many ratings.

## `maxTotalTimeMinutes` (type: `integer`):

Drop recipes whose `prep + cook` time exceeds this many minutes.

## `keywordIncludes` (type: `string`):

Drop recipes whose name + description don't contain this keyword.

## `proxy` (type: `object`):

Apify Proxy is optional. For Epicurious / Tasty / BBC Good Food / NYT Cooking / most food blogs, no proxy is needed; datacenter or residential both work. Provided here for sites that occasionally rate-limit.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "byUrls",
  "recipeUrls": [
    "https://www.epicurious.com/recipes/food/views/banana-bread"
  ],
  "tagUrls": [],
  "sitemapUrls": [],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxItems": 50
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of all scraped recipes.

# 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 = {
    "mode": "byUrls",
    "recipeUrls": [
        "https://www.epicurious.com/recipes/food/views/banana-bread"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/recipe-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 = {
    "mode": "byUrls",
    "recipeUrls": ["https://www.epicurious.com/recipes/food/views/banana-bread"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/recipe-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 '{
  "mode": "byUrls",
  "recipeUrls": [
    "https://www.epicurious.com/recipes/food/views/banana-bread"
  ],
  "maxItems": 50
}' |
apify call crawlerbros/recipe-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Recipe Scraper (Universal / schema.org)",
        "description": "Scrape any schema.org-compliant recipe site like Epicurious, BBC Good Food, Tasty, NYT Cooking, Serious Eats, Food Network, plus thousands of food blogs. Extracts ingredients, instructions, nutrition, ratings, prep/cook time, yield, author, and images via JSON-LD parsing.",
        "version": "1.0",
        "x-build-id": "aUhyUDKrg3vhfM12x"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~recipe-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-recipe-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/crawlerbros~recipe-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-recipe-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/crawlerbros~recipe-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-recipe-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byUrls",
                            "byTag",
                            "bySitemap"
                        ],
                        "type": "string",
                        "description": "How to source recipe URLs.",
                        "default": "byUrls"
                    },
                    "recipeUrls": {
                        "title": "Recipe URLs (mode=byUrls)",
                        "type": "array",
                        "description": "Recipe URLs from any schema.org-compliant site (Epicurious, BBC Good Food, Tasty, NYT Cooking, Bon Appétit, Serious Eats, Food Network, King Arthur Baking, food blogs, etc.). AllRecipes URLs are rejected as unsupported.",
                        "default": [
                            "https://www.epicurious.com/recipes/food/views/banana-bread"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tagUrls": {
                        "title": "Tag URLs (mode=byTag)",
                        "type": "array",
                        "description": "Epicurious tag/category URLs OR bare slugs. Examples: `https://www.epicurious.com/recipes/category/main-course`, `/ingredient/banana`, `dessert`. The actor scrapes the tag page → finds recipe URLs → fetches each.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sitemapUrls": {
                        "title": "Sitemap URLs (mode=bySitemap)",
                        "type": "array",
                        "description": "Sitemap.xml URLs from any recipe site (e.g. `https://www.bbcgoodfood.com/sitemap.xml`, `https://www.epicurious.com/sitemap.xml`, or a deeper recipe-only sitemap). The actor walks the sitemap (one level deep into sitemap indexes), filters recipe-looking URLs, and runs them through the JSON-LD pipeline.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minRating": {
                        "title": "Min rating (optional)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Drop recipes with `ratingValue` below this. Scale 0-500 (e.g. 400 = 4.0/5)."
                    },
                    "minRatingCount": {
                        "title": "Min rating count (optional)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop recipes with fewer than this many ratings."
                    },
                    "maxTotalTimeMinutes": {
                        "title": "Max total time (minutes)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop recipes whose `prep + cook` time exceeds this many minutes."
                    },
                    "keywordIncludes": {
                        "title": "Must contain keyword (optional)",
                        "type": "string",
                        "description": "Drop recipes whose name + description don't contain this keyword."
                    },
                    "proxy": {
                        "title": "Apify Proxy (optional)",
                        "type": "object",
                        "description": "Apify Proxy is optional. For Epicurious / Tasty / BBC Good Food / NYT Cooking / most food blogs, no proxy is needed; datacenter or residential both work. Provided here for sites that occasionally rate-limit.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```