# King Arthur Baking Scraper | Baking Recipes (`parseforge/kingarthurbaking-scraper`) Actor

Collect baking recipes from King Arthur Baking with ingredients, methods, prep and bake times, yield, ratings, tips, and nutrition info. Power baking apps, recipe collections, meal planners, and culinary AI datasets with expert-tested content from a trusted baking brand.

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

## 🥖 King Arthur Baking Scraper

> 🚀 **Export King Arthur Baking recipes in seconds.** Search **1,500+ tested recipes** by keyword - get ingredients, instructions, ratings, reviews, tips, and more. No API key, no registration, no manual copy-pasting.

> 🕒 **Last updated:** 2026-05-22 · **📊 18 fields** per record · **🥖 1,500+ recipes** · **🍰 15+ categories** · **⭐ Community ratings and reviews**

The **King Arthur Baking Scraper** extracts the complete recipe catalog from King Arthur Baking Company (kingarthurbaking.com) - one of the most trusted baking authorities in North America. Each record delivers **18 fields**, including ingredients, step-by-step instructions, prep/cook/total times, yield, ratings, review counts, author credits, baker tips, and categorized tags. All recipe data is structured via JSON-LD and verified by the King Arthur test kitchen.

The catalog spans **over 1,500 recipes across 15+ categories** - from sourdough breads and yeasted pastries to cookies, cakes, pies, and pizza. King Arthur recipes are precision-tested, gram-weighted, and authored by professional bakers. This Actor makes that dataset downloadable as CSV, Excel, JSON, or XML in under a minute. Just set your search term and let it run.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Food tech teams, recipe app developers, nutrition analysts, culinary researchers, baking educators, content creators, meal planning services | Recipe database building, ingredient analysis, nutrition research, baking instruction datasets, content enrichment, recipe recommendation engines |

---

### 📋 What the King Arthur Baking Scraper does

Flexible search-driven collection in a single run:

- 🔍 **Keyword search.** Find recipes matching any search term - "sourdough bread", "chocolate cake", "gluten-free cookies", "focaccia", and more.
- 🥖 **Bread recipes.** Hundreds of tested yeast breads, sourdough loaves, sandwich breads, and enriched doughs.
- 🍰 **Dessert recipes.** Cakes, cookies, bars, pies, tarts, cheesecakes, muffins, and more.
- 🍕 **Savory recipes.** Pizza doughs, flatbreads, crackers, pasta, and main dishes.
- ⭐ **Ratings and reviews.** Community ratings and review counts from verified bakers.
- 📝 **Baker tips.** Expert tips from the King Arthur test kitchen included with each recipe.

Each record includes full ingredients, numbered instructions, precise timing, yield, author name, category tags, image URL, and publication date.

> 💡 **Why it matters:** King Arthur Baking recipes are precision-tested with gram weights and professional-grade instructions. Building your own scraper means parsing Drupal structured data, handling JSON-LD edge cases, and re-scraping manually. This Actor does it all automatically and returns clean, structured data on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded recipe dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Recipes to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>"bread"</code></td><td>Search term to filter recipes. Matches against recipe slugs - e.g., "sourdough", "chocolate cake", "gluten-free".</td></tr>
</tbody>
</table>

**Example: 50 sourdough recipes.**

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

**Example: 20 cookie recipes.**

```json
{
    "searchQuery": "cookie",
    "maxItems": 20
}
```

> ⚠️ **Good to Know:** the scraper filters recipes by matching the search term against recipe URL slugs. For best results, use simple ingredient or technique keywords like "bread", "chocolate", "sourdough", "muffin", "pizza", "gluten free". If no specific match is found, the scraper returns a broader set of recipes from the catalog.

***

### 📊 Output

Each recipe record contains **18 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼 `imageUrl` | string | `"https://www.kingarthurbaking.com/sites/default/files/2021-04/Vermont-Maple-Oatmeal-Bread-21-3_01-web.jpg"` |
| 📌 `title` | string | `"Honey Oatmeal Bread"` |
| 📝 `description` | string | `"A wholesome sandwich loaf sweetened with honey and enriched with oats..."` |
| 👤 `author` | string | `"PJ Hamel"` |
| ⭐ `rating` | number | `4.3` |
| 💬 `reviewCount` | integer | `45` |
| 🥣 `ingredients` | array | `["3/4 cup (170g) boiling water", "1 cup (90g) old-fashioned rolled oats", ...]` |
| 📋 `instructions` | array | `["Combine the boiling water and oats...", "Add the flour, yeast, salt...", ...]` |
| ⏱ `prepTime` | string | `"20 min"` |
| 🍳 `cookTime` | string | `"35 min"` |
| ⏰ `totalTime` | string | `"3 hr 10 min"` |
| 🍽 `yield` | string | `"one 8 1/2\" x 4 1/2\" loaf"` |
| 🔖 `tags` | array | `["Sandwich bread", "Honey"]` |
| 🏷 `category` | string | `"Bread"` |
| 💡 `tips` | array | `["Because of its high oat content, this bread may have a slightly craggy surface...", ...]` |
| 🔗 `url` | string | `"https://www.kingarthurbaking.com/recipes/honey-oatmeal-bread-recipe"` |
| 📅 `publishedAt` | string | `"December 31, 2009 at 7:00pm"` |
| 🕒 `scrapedAt` | string | `"2026-05-22T03:45:46.863Z"` |

#### 📄 Sample Records

```json
[
  {
    "imageUrl": "https://www.kingarthurbaking.com/sites/default/files/2021-04/Vermont-Maple-Oatmeal-Bread-21-3_01-web.jpg",
    "title": "Vermont Oatmeal and Maple Bread for the Mini Zo Bread Machine",
    "description": "This hearty dough, bolstered with oats and walnuts and lightly sweetened with maple syrup, is the perfect candidate for a small bread machine like the \"Mini Zo\"...",
    "author": "Mary Tinkham",
    "rating": 4.6,
    "reviewCount": 24,
    "ingredients": [
      "3/4 cup plus 2 tablespoons (198g) warm water",
      "2 1/2 tablespoons (50g) maple syrup",
      "1 1/2 tablespoons (21g) melted butter",
      "1 2/3 cups (200g) King Arthur Unbleached Bread Flour",
      "2/3 cup (60g) old-fashioned rolled oats",
      "2/3 cup (113g) walnut pieces",
      "1 3/4 teaspoons instant yeast",
      "1 teaspoon (6g) table salt"
    ],
    "instructions": [
      "Weigh your flour; or measure it by gently spooning it into a cup, then sweeping off any excess.",
      "Place the ingredients, in order, in your bread machine. Set the machine for the white bread cycle. Press Start.",
      "When the bread is done, remove it from the pan, and turn it onto a rack to cool."
    ],
    "prepTime": "10 min",
    "cookTime": "1 hr 10 min",
    "totalTime": "3 hr 30 min",
    "yield": "1 loaf",
    "tags": ["Sandwich bread", "Maple", "Bread machine"],
    "category": "Bread",
    "tips": [],
    "url": "https://www.kingarthurbaking.com/recipes/vermont-oatmeal-and-maple-bread-for-the-mini-zo-bread-machine-recipe",
    "publishedAt": "December 31, 2009 at 7:00pm",
    "scrapedAt": "2026-05-22T03:45:44.314Z",
    "error": null
  },
  {
    "imageUrl": "https://www.kingarthurbaking.com/sites/default/files/recipe_legacy/HONEYOATMEAL.jpg",
    "title": "Honey Oatmeal Bread",
    "description": "An absolutely delicious bread for everyone - a bit sweet, a bit hearty, with a tender, moist crumb. Perfect for toast or sandwiches.",
    "author": "PJ Hamel",
    "rating": 4.3,
    "reviewCount": 45,
    "ingredients": [
      "1 cup (227g) boiling water",
      "1 cup (90g) old-fashioned rolled oats",
      "1/3 cup (113g) honey",
      "2 tablespoons (28g) butter",
      "1 1/2 teaspoons (9g) salt",
      "2 1/4 teaspoons instant yeast",
      "1/3 cup (74g) lukewarm water",
      "3 cups (360g) King Arthur Unbleached All-Purpose Flour",
      "1 cup (120g) King Arthur White Whole Wheat Flour",
      "1/3 cup (30g) old-fashioned rolled oats, for topping",
      "1 tablespoon milk, for brushing"
    ],
    "instructions": [
      "Combine the boiling water, oats, honey, butter, and salt. Stir until combined, and let cool to lukewarm.",
      "Weigh your flour; or measure it by gently spooning it into a cup, then sweeping off any excess.",
      "Add the yeast, lukewarm water, and flours. Mix and knead to make a smooth, soft dough.",
      "Cover and let rise for 1 to 2 hours, or until doubled in size.",
      "Gently deflate the dough, shape it into a log, and place it in a lightly greased 8 1/2 x 4 1/2 pan.",
      "Cover and let rise for 1 to 1 1/2 hours, until it crowns 1 inch over the rim of the pan.",
      "Brush with milk and sprinkle with oats. Bake in a preheated 350 degrees F oven for 35 to 40 minutes.",
      "Remove from oven and cool on a rack before slicing."
    ],
    "prepTime": "20 min",
    "cookTime": "35 min",
    "totalTime": "3 hr 10 min",
    "yield": "one 8 1/2\" x 4 1/2\" loaf",
    "tags": ["Sandwich bread", "Honey"],
    "category": "Bread",
    "tips": [
      "Because of its high oat content, this bread may have a slightly craggy surface; that's normal.",
      "The type of oats you use DOES make a difference; quick oats absorb more liquid than rolled oats.",
      "When making yeast bread, let the dough rise to the point the recipe says, rather than watching the clock."
    ],
    "url": "https://www.kingarthurbaking.com/recipes/honey-oatmeal-bread-recipe",
    "publishedAt": "December 31, 2009 at 7:00pm",
    "scrapedAt": "2026-05-22T03:45:45.629Z",
    "error": null
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🥖 **1,500+ tested recipes** | Every recipe from King Arthur's professional test kitchen |
| 📊 **18 structured fields** | Complete data including gram-weighted ingredients and numbered instructions |
| ⭐ **Ratings and reviews** | Community-verified ratings and review counts on every record |
| 💡 **Baker tips included** | Expert tips from King Arthur test kitchen bakers |
| 🔍 **Flexible keyword search** | Find any category or ingredient - bread, cookies, sourdough, pizza, gluten-free |
| 🔗 **Sitemap-based discovery** | Reliably discovers all 1,500+ recipes from the XML sitemap |
| ⚡ **Fast JSON-LD parsing** | Extracts structured data directly - no fragile CSS selector chains |
| 🌐 **No auth required** | King Arthur Baking is fully public - no login, no API key needed |

***

### 📈 How it compares to alternatives

| Actor | Recipes | Fields | Ratings | Baker Tips | Search |
|---|---|---|---|---|---|
| **King Arthur Baking Scraper** | 1,500+ | 18 | Yes | Yes | Keyword |
| Manual copy-paste | 1 at a time | Incomplete | No | No | No |
| Generic recipe scrapers | Varies | 5-8 | Sometimes | No | No |
| Allrecipes scraper | 100,000+ | 15 | Yes | No | Yes |

***

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Open the **King Arthur Baking Scraper** in the Apify Store
3. Set your **Search Query** (e.g., "sourdough bread", "chocolate cake", "cookies")
4. Set **Max Items** (10 for free preview, up to 1,000,000 for paid)
5. Click **Start** and wait 10-60 seconds
6. Download your dataset as **CSV, Excel, JSON, or XML**

***

### 💼 Business use cases

#### 🍽 Recipe App Development

Build or enrich a recipe database with 1,500+ precision-tested baking recipes. Each record includes gram-weighted ingredients, step-by-step instructions, yield, timing, and community ratings - everything needed to power a recipe card display.

#### 📊 Nutrition and Food Research

Analyze ingredient patterns across hundreds of tested recipes - which flours are most popular, how sugar content varies across dessert categories, or how prep times differ between yeasted and quick breads. Use the structured ingredients array for NLP and nutrition lookup pipelines.

#### 🎓 Culinary Education

Build educational datasets for baking courses. King Arthur recipes include detailed explanations, technique guidance in the instructions, and professional baker tips - ideal source material for culinary instruction content.

#### 🤖 AI and Recommendation Systems

Train recipe recommendation models on high-quality, labeled baking data. Each record includes category, tags, ratings, and complete ingredient/instruction text - rich training signal for NLP, semantic search, and recommendation engines.

***

### 🔌 Automating King Arthur Baking Scraper

Connect your recipe data to any automation platform:

- **Make (Integromat):** Trigger on schedule - run weekly to refresh your database with new recipes, then push to Google Sheets or Airtable.
- **Zapier:** When the actor completes, push recipe data to a Notion database or send a Slack notification with new recipe counts.
- **Slack:** Weekly digest of newly added King Arthur Baking recipes direct to your team channel.
- **Airtable / Google Sheets:** Live recipe database that refreshes automatically - great for editorial teams and recipe app content pipelines.
- **REST API:** Use the Apify API to trigger runs, fetch datasets, and integrate recipe data into any backend service.

***

### 🌟 Beyond business use cases

#### 🔬 Academic Research

Study how professional recipe development has evolved over time using the `publishedAt` field. Analyze ingredient trends, technique frequency, and rating patterns across 1,500+ recipes from a single authoritative source.

#### 🎨 Creative Projects

Build a personalized baking planner, a random-recipe-of-the-day bot, or a "what can I bake with these ingredients" app. The structured ingredients array is perfect for ingredient-matching logic.

#### 🌱 Non-Profit and Community

Food banks and community kitchens can use King Arthur recipes as high-quality, accessible baking instruction resources - grain-based, affordable ingredients with detailed technique guidance.

#### 🧪 Experimentation

Test recipe recommendation algorithms, ingredient substitution logic, or natural language parsing pipelines on real-world professional recipe data with community validation signals.

***

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant (Claude, ChatGPT, Gemini) to help you use this Actor:

*"I'm using the King Arthur Baking Scraper on Apify. Help me write a Python script to load the JSON dataset and filter recipes with more than 4.5 stars and at least 20 reviews."*

*"How do I connect the King Arthur Baking Scraper to Google Sheets using Make.com?"*

*"What's the best way to use the ingredients array to build a grocery list aggregator?"*

***

### ❓ Frequently Asked Questions

#### 🤔 Does this scraper need an API key or login?

No. King Arthur Baking is fully public. No account, API key, or authentication required.

#### 📦 How many recipes are available?

The catalog contains 1,500+ recipes across 15+ categories including bread, cookies, cakes, muffins, pizza, sourdough, and more.

#### 🔍 How does the search work?

The scraper fetches the King Arthur Baking XML sitemap to discover all recipe URLs, then filters them by matching your search term against the recipe slugs. Simple one-word terms ("bread", "chocolate", "sourdough") work best.

#### 🍰 What categories are available?

Bread, Buns & Rolls, Cake, Cheesecake, Coffee Cake, Cookies & Bars, Crackers, Muffins, Pancakes & Waffles, Pies & Tarts, Pizza, Scones, Sourdough, and more.

#### ⭐ Are ratings real?

Yes. Ratings and review counts are scraped directly from the `aggregateRating` field in each recipe's JSON-LD structured data, which reflects community reviews on the site.

#### 💡 What are baker tips?

Baker tips are expert notes added by the King Arthur test kitchen team - practical advice on ingredient substitutions, technique variations, storage, and troubleshooting. Not all recipes have them.

#### 📅 What format is the published date?

The `publishedAt` field contains the date string exactly as provided by King Arthur Baking's structured data - e.g., "December 31, 2009 at 7:00pm".

#### 🔄 How often should I re-run?

King Arthur publishes new recipes regularly. Running monthly will capture new additions. Use `maxItems` to control how many recipes you retrieve per run.

#### 📊 Can I download as Excel?

Yes. The Apify platform supports CSV, JSON, XML, and Excel (XLSX) export from any dataset.

#### 🆓 What's free vs. paid?

Free plan: preview up to 10 recipes per run. Paid plan: up to 1,000,000 recipes per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

#### 🔧 What happens if a recipe has no JSON-LD?

The scraper skips the page and moves on to the next URL. This is rare on King Arthur Baking as they use consistent structured data on all recipe pages.

#### 🌐 Does this work on all King Arthur recipe types?

Yes - bread, desserts, savory recipes, gluten-free recipes, and seasonal collections are all included in the sitemap and scraped the same way.

***

### 🔌 Integrate with any app

| Platform | Method |
|---|---|
| Google Sheets | Apify → Google Sheets integration via Make or Zapier |
| Airtable | REST API or Make.com Airtable module |
| Notion | Apify webhook + Notion API |
| Slack | Apify webhook → Slack message on completion |
| PostgreSQL / MySQL | Download JSON, import via CLI or ETL tool |
| BigQuery | Apify API → GCS → BigQuery load job |
| Excel / Power BI | Download XLSX from Apify dataset |
| CSV / pandas | Download CSV, load with `pd.read_csv()` |
| REST API | `GET https://api.apify.com/v2/datasets/{id}/items?format=json` |
| Zapier | Apify Zapier app triggers on run completion |
| Make (Integromat) | Apify Make module, schedule or webhook trigger |
| n8n | Apify node, HTTP request node |

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Allrecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) | 100,000+ community recipes with ratings, reviews, and nutrition info |
| [Food.com Scraper](https://apify.com/parseforge/food-com-scraper) | Large community recipe database with user-submitted recipes |
| [Serious Eats Scraper](https://apify.com/parseforge/seriouseats-scraper) | Professional culinary recipes with deep technique explanations |
| [Epicurious Scraper](https://apify.com/parseforge/epicurious-scraper) | Bon Appetit and Epicurious tested recipes with professional photography |
| [Simply Recipes Scraper](https://apify.com/parseforge/simplyrecipes-scraper) | Family-friendly recipes with dietary filters and step-by-step photos |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ ready-to-use scrapers covering recipes, jobs, real estate, reviews, and more.

***

*Disclaimer: This Actor is independently developed and is not affiliated with, endorsed by, or officially connected to King Arthur Baking Company. All recipe data is publicly available on kingarthurbaking.com. Use responsibly and in accordance with the site'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`):

Search term to find recipes (e.g. 'sourdough bread', 'chocolate cake', 'cookies')

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

Optional recipe category to filter by (e.g. 'bread', 'cake', 'cookies-bars', 'sourdough', 'pizza'). Leave empty to search all categories.

## Actor input object example

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

# 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": "bread"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "King Arthur Baking Scraper | Baking Recipes",
        "description": "Collect baking recipes from King Arthur Baking with ingredients, methods, prep and bake times, yield, ratings, tips, and nutrition info. Power baking apps, recipe collections, meal planners, and culinary AI datasets with expert-tested content from a trusted baking brand.",
        "version": "0.1",
        "x-build-id": "ZiwbbBa4E0P6Klbkg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~kingarthurbaking-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-kingarthurbaking-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~kingarthurbaking-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-kingarthurbaking-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~kingarthurbaking-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-kingarthurbaking-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": "Search term to find recipes (e.g. 'sourdough bread', 'chocolate cake', 'cookies')"
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Optional recipe category to filter by (e.g. 'bread', 'cake', 'cookies-bars', 'sourdough', 'pizza'). 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
