# Allrecipes Scraper - Recipe and Nutritional Data (`parseforge/allrecipes-scraper`) Actor

Scrape thousands of recipes from Allrecipes.com, including ingredients, step-by-step instructions, ratings, reviews, nutrition facts, cook time, prep time, and serving size. Great for building meal planning apps, food databases, and nutrition research tools.

- **URL**: https://apify.com/parseforge/allrecipes-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, 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)

## 🍝 Allrecipes Scraper

> 🚀 **Export Allrecipes recipes to CSV, JSON, or Excel in seconds.** No API key, no login, no code required.

> 🕒 **Last updated:** 2026-05-21 · **📊 17 fields** per record · **Millions of recipes** · **Global coverage**

Allrecipes is one of the world's most-visited food sites, hosting millions of community-reviewed recipes across every cuisine and dietary preference. This actor scrapes recipes directly from the Allrecipes website using structured data - giving you clean, structured recipe data including ingredients, step-by-step instructions, ratings, nutrition, cook times, and more. No account or API access required.

The data is extracted in real-time from Allrecipes' own structured JSON-LD markup, ensuring accuracy and completeness for every recipe field.

**Coverage:** Pasta, chicken, desserts, vegetarian, vegan, gluten-free, holiday recipes, quick meals, slow cooker recipes, and every category Allrecipes supports - searched by any keyword.

### Target Audience / Use Cases

| Who | What they build |
|-----|----------------|
| Food bloggers | Competitor analysis, trend research |
| Nutrition researchers | Large-scale calorie and ingredient datasets |
| Meal planning apps | Recipe database population |
| AI / ML teams | Training data for recipe models |
| Grocery / retail | Ingredient demand forecasting |
| Content marketers | Recipe content inspiration and gap analysis |

### 📋 What the Allrecipes Scraper does

- Search any keyword (e.g. "pasta", "chicken dinner", "vegan dessert")
- Paginate through search results to collect as many recipes as needed
- Extract full structured data from each recipe page: ingredients, instructions, ratings, nutrition
- Export to CSV, Excel, JSON, or XML with one click
- Works without login or API key

> 💡 **Why it matters:** Allrecipes has over 50,000 recipes with community reviews going back decades. This dataset is a gold mine for nutrition research, meal planning products, AI training, and food trend analysis.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `maxItems` | integer | No | Max recipes to collect. Free users limited to 10. |
| `search` | string | No | Search query (e.g. "pasta", "chicken soup"). Default: "pasta" |
| `category` | string | No | Optional category filter (e.g. "vegetarian", "dessert") |

**Example 1 - Basic search:**
```json
{
  "maxItems": 50,
  "search": "pasta"
}
````

**Example 2 - Category search:**

```json
{
  "maxItems": 100,
  "search": "chicken",
  "category": "dinner"
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 recipes per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 recipes per run.

### 📊 Output

Each recipe record contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| 🖼 `imageUrl` | string | Main recipe photo URL |
| 📌 `title` | string | Recipe name |
| 👤 `author` | string | Recipe creator |
| ⭐ `rating` | number | Aggregate star rating (1-5) |
| 💬 `reviewCount` | number | Total number of reviews |
| ⏱ `prepTime` | string | Preparation time (e.g. "20 min") |
| 🍳 `cookTime` | string | Cook time (e.g. "30 min") |
| ⏰ `totalTime` | string | Total time from start to finish |
| 🍽 `servings` | string | Number of servings |
| 🔥 `calories` | string | Calories per serving |
| 🥗 `ingredients` | array | Full ingredient list with quantities |
| 📋 `instructions` | array | Step-by-step cooking instructions |
| 🏷 `category` | string | Recipe category (e.g. "Dinner", "Lunch") |
| 🔗 `url` | string | Direct link to the recipe page |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp of collection |
| ❌ `error` | string | Error message if scraping failed (null otherwise) |

**Sample output record:**

```json
{
  "imageUrl": "https://www.allrecipes.com/thmb/b0JoulfOsZDw7VHEFxQjPCrpus4=/1500x0/filters:no_upscale():max_bytes(150000):strip_icc()/14385-pasta-salad-DDMFS-4x3-28eb5dbe00624780b36cabfef15ca183.jpg",
  "title": "Pasta Salad",
  "author": "Cyndie",
  "rating": 4.7,
  "reviewCount": 321,
  "prepTime": "20 min",
  "cookTime": "10 min",
  "totalTime": "30 min",
  "servings": "6",
  "calories": "400 kcal",
  "ingredients": [
    "1 pound tri-colored spiral pasta",
    "1 (16 ounce) bottle Italian-style salad dressing",
    "6 tablespoons salad seasoning mix",
    "2 cups cherry tomatoes, diced",
    "1 green bell pepper, chopped",
    "1 red bell pepper, diced",
    "0.5 yellow bell pepper, chopped",
    "1 (2.25 ounce) can black olives, chopped"
  ],
  "instructions": [
    "Gather all ingredients.",
    "Bring a large pot of lightly salted water to a boil. Cook pasta in the boiling water, stirring occasionally, until tender yet firm to the bite, about 10 to 12 minutes; rinse under cold water and drain.",
    "Whisk Italian dressing and salad spice mix together until smooth. Combine pasta, tomatoes, bell peppers, and olives in a salad bowl.",
    "Pour dressing over salad and toss to coat.",
    "For the best flavor, refrigerate the pasta salad for 8 hours to overnight.",
    "Enjoy!"
  ],
  "category": "Lunch",
  "url": "https://www.allrecipes.com/recipe/14385/pasta-salad/",
  "scrapedAt": "2026-05-21T23:17:49.106Z",
  "error": null
}
```

**Second sample - Basic Homemade Pasta:**

```json
{
  "imageUrl": "https://www.allrecipes.com/thmb/6pENC13Ep6dvQKaUagFevca7r9w=/1500x0/filters:no_upscale():max_bytes(150000):strip_icc()/AR-11899-basic-pasta-4x3-hero-89f27506618044bd8dad72a436aff32d.jpg",
  "title": "Basic Homemade Pasta",
  "author": "Pat",
  "rating": 4.5,
  "reviewCount": 633,
  "prepTime": "25 min",
  "cookTime": null,
  "totalTime": "25 min",
  "servings": "3",
  "calories": "176 kcal",
  "ingredients": [
    "1 cup all-purpose flour",
    "0.5 teaspoon salt",
    "1 egg, beaten",
    "2 tablespoons water"
  ],
  "instructions": [
    "Gather all ingredients.",
    "Combine flour and salt in a medium bowl. Make a well in the center and add beaten egg. Mix well until a stiff dough forms, adding up to 2 tablespoons water if needed.",
    "Knead dough on a lightly floured surface until smooth, 3 to 4 minutes. Wrap dough and let rest for 30 minutes to 1 hour.",
    "Roll dough by hand or with a pasta machine to desired thickness, then cut into strips of desired width and length."
  ],
  "category": "Dinner",
  "url": "https://www.allrecipes.com/recipe/11899/basic-pasta/",
  "scrapedAt": "2026-05-21T23:17:49.106Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Detail |
|---------|--------|
| 🚀 No login required | Scrapes public Allrecipes data without any authentication |
| 📊 Full structured data | Ingredients, instructions, ratings, nutrition - all in one record |
| ⚡ Fast extraction | Uses JSON-LD structured data for reliable, fast parsing |
| 🔍 Flexible search | Search any keyword or combine with category filters |
| 📦 Multiple export formats | CSV, Excel, JSON, XML - download instantly |
| 🆓 Free tier available | 10 free recipes per run to test before upgrading |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Allrecipes API |
|---------|-----------|-----------------|---------------|
| No API key needed | Yes | Yes | No |
| Structured output | Yes | No | Yes |
| Bulk export | Yes | No | Limited |
| Ingredients + instructions | Yes | Manual | Yes |
| Ratings + reviews | Yes | Manual | Limited |
| Free tier | Yes | N/A | No |

### 🚀 How to use

1. Go to the [Allrecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) page on Apify
2. Click **Try for free**
3. Enter your search query (e.g. "pasta", "chicken dinner", "vegan cake")
4. Set `maxItems` to control how many recipes to collect
5. Click **Start** and wait for the run to complete (usually under 1 minute for 50 recipes)
6. Download results as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Nutrition and Health Research

Track calorie counts, macronutrients, and ingredient patterns across thousands of recipes. Build datasets for dietary analysis, identify trends in low-carb or high-protein recipes, or compare nutritional content across cuisine types.

#### Meal Planning Applications

Populate a meal planning app with structured recipe data including cook times, servings, and full ingredient lists. Use the search filter to seed your database with specific cuisine types or dietary preferences.

#### Food AI and Machine Learning

Build training datasets for recipe recommendation engines, ingredient substitution models, or cooking time predictors. The structured format of ingredients and instructions is ideal for NLP and ML pipelines.

#### Content Marketing and SEO

Research competitor recipe content, identify keyword gaps in specific categories, or analyze which recipe types generate the most community engagement based on review counts and ratings.

### 🔌 Automating Allrecipes Scraper

Connect this actor to your favorite tools without code:

- **Make (Integromat)** - Schedule weekly runs and push results to Google Sheets
- **Zapier** - Trigger on run completion and send data to Airtable or Notion
- **Slack** - Get notified when a scraping run completes
- **Google Sheets** - Export directly via Apify's Google Sheets integration
- **REST API** - Call the actor from any language using Apify's HTTP API

### 🌟 Beyond business use cases

#### Personal Recipe Collections

Build your own searchable recipe database from Allrecipes. Export pasta recipes, filter by rating, and organize into a personal cookbook spreadsheet.

#### Academic Research

Study food culture, linguistic patterns in recipe writing, or seasonal ingredient trends using large-scale recipe datasets.

#### Non-Profit Nutrition Programs

Community kitchens and food banks can use this to build low-cost, high-nutrition meal plans with full ingredient data.

#### Culinary Experimentation

Collect hundreds of variations of the same dish (e.g. "chocolate chip cookies") to analyze how ingredient ratios differ across community recipes.

### 🤖 Ask an AI assistant about this scraper

You can ask an AI assistant (Claude, ChatGPT, Gemini, etc.) about this data:

- "What are the most common ingredients in 5-star pasta recipes?"
- "Which recipes under 30 minutes have the highest ratings?"
- "Summarize the nutritional content of these 50 chicken recipes."
- "Identify recipes suitable for someone avoiding gluten."

Just export the dataset as JSON and paste it into your AI chat.

### ❓ Frequently Asked Questions

**❓ Does this scraper require an Allrecipes account?**
No. All data is scraped from publicly accessible recipe pages without any login.

**❓ How many recipes can I scrape?**
Free users get 10 recipes per run. Paid users can collect up to 1,000,000 per run.

**❓ How fast is it?**
Roughly 1-2 seconds per recipe. 100 recipes takes about 2-3 minutes. 1,000 recipes takes 20-30 minutes.

**❓ What search queries work best?**
Single words like "pasta", "chicken", or "cake" return the broadest results. Phrases like "chicken dinner" or "vegan dessert" narrow results to that category.

**❓ Can I filter by category?**
Yes - use the `category` input field with values like "vegetarian", "dinner", "dessert", "breakfast".

**❓ Are the ingredients in a structured format?**
Ingredients are returned as an array of strings, each containing quantity and ingredient name as shown on the recipe page (e.g. "1 cup all-purpose flour").

**❓ What happens if a recipe page has no data?**
If a recipe page cannot be parsed, an `error` field is populated and the item is skipped. It does not count toward your `maxItems`.

**❓ Are ratings real community ratings?**
Yes. Ratings and review counts are the live aggregate community ratings from Allrecipes.

**❓ Can I get recipe photos?**
Yes. The `imageUrl` field contains the full-resolution image URL hosted on Allrecipes' CDN.

**❓ Is this legal to use?**
This actor scrapes publicly available information. Always review Allrecipes' Terms of Service and ensure your use case complies with applicable laws before commercial use.

### 🔌 Integrate with any app

Export your Allrecipes dataset to:

- **Google Sheets** via Apify integration
- **Airtable** via Make or Zapier
- **Notion** via Zapier
- **BigQuery** via Apify's data pipeline
- **MongoDB / PostgreSQL** via REST API export
- **Excel / CSV** direct download from Apify console
- **Python / Node.js** via Apify SDK or HTTP API

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Product Hunt Scraper](https://apify.com/parseforge/producthunt-scraper) | Scrape product launches, reviews, and maker data from Product Hunt |
| [Trustpilot Reviews Scraper](https://apify.com/parseforge/trustpilot-reviews-scraper) | Extract verified business reviews from Trustpilot |
| [Yelp Reviews Scraper](https://apify.com/parseforge/yelp-reviews-scraper) | Collect restaurant and business reviews from Yelp |

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

***

**Disclaimer:** This actor is not affiliated with, endorsed by, or sponsored by Allrecipes or Dotdash Meredith. It scrapes publicly available data for research and automation purposes. Users are responsible for complying with Allrecipes' Terms of Service and applicable laws when using the extracted data.

# Actor input Schema

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

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

## `search` (type: `string`):

Search term to find recipes (e.g. 'pasta', 'chicken dinner', 'chocolate cake')

## `category` (type: `string`):

Optional category filter (e.g. 'chicken dinner', 'vegetarian', 'dessert'). Leave empty to search all categories.

## Actor input object example

```json
{
  "maxItems": 10,
  "search": "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,
    "search": "pasta"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Allrecipes Scraper - Recipe and Nutritional Data",
        "description": "Scrape thousands of recipes from Allrecipes.com, including ingredients, step-by-step instructions, ratings, reviews, nutrition facts, cook time, prep time, and serving size. Great for building meal planning apps, food databases, and nutrition research tools.",
        "version": "0.1",
        "x-build-id": "fUrw8Jl4Nna9i249P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~allrecipes-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-allrecipes-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~allrecipes-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-allrecipes-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~allrecipes-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-allrecipes-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"
                    },
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find recipes (e.g. 'pasta', 'chicken dinner', 'chocolate cake')"
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Optional category filter (e.g. 'chicken dinner', 'vegetarian', 'dessert'). Leave empty to search all categories."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
