# Yummly Scraper | Personalized Recipes Database (`parseforge/yummly-scraper`) Actor

Extract recipes from Yummly with ingredients, instructions, prep and cook times, servings, nutrition, ratings, cuisine, and dietary tags. Filter by diet, allergy, or ingredient to power recipe apps, meal planners, food platforms, and AI cooking assistant training datasets.

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

## 🍝 Yummly Recipe Scraper

> 🚀 **Export Yummly recipes with ingredients, cook time, servings, and difficulty in seconds.** No API key required - just enter a search query and download.

> 🕒 **Last updated:** 2026-05-22 · **📊 8 fields** per record · **1,500+ recipes** · **Global coverage**

The Yummly Recipe Scraper pulls structured recipe data from Yummly - now hosted at KitchenAid.com - including full ingredient lists, cook times, difficulty, servings, and recipe tags. All data is scraped in real-time via the site's internal API, returning clean JSON, CSV, or Excel exports ready for immediate use.

The dataset covers all recipe categories available on Yummly/KitchenAid: pasta, baking, soups, salads, desserts, breakfast, and more - with filters by search keyword.

### Target Audience and Use Cases

| Use Case | Who Benefits |
|---|---|
| Meal planning apps | Developers building recipe recommendation features |
| Nutrition research | Researchers analyzing ingredient patterns |
| Recipe NLP datasets | AI/ML teams training food-related models |
| Cooking content | Bloggers, food writers, and content creators |
| Culinary databases | Restaurants and catering companies |
| Academic research | Food science and nutrition students |

### 📋 What the Yummly Scraper Does

- Searches Yummly recipes by keyword (e.g., "pasta", "chicken", "vegan")
- Returns full ingredient lists with amounts and units
- Extracts cook time, difficulty level, servings, and course type
- Exports clean JSON, CSV, or Excel for immediate use
- Handles pagination automatically up to `maxItems`

> 💡 **Why it matters:** Yummly hosts thousands of tested recipes from KitchenAid's culinary team. This scraper gives you structured access to all of them without manual copy-pasting.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | string | `pasta` | Keyword to search recipes by |
| `maxItems` | integer | `10` | Maximum number of recipes to return |

**Example - search for chicken recipes:**
```json
{
    "searchQuery": "chicken",
    "maxItems": 50
}
````

**Example - scrape all recipes:**

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

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

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Recipe photo URL |
| 📌 `title` | string | Recipe name |
| 🔗 `url` | string | Full recipe URL |
| ⏱️ `totalTime` | integer | Total time in minutes |
| 🍽️ `servings` | integer | Number of servings |
| 🧂 `ingredients` | array | Ingredient list with amounts |
| 🏷️ `tags` | array | Course, cuisine, and tool tags |
| 📊 `difficulty` | string | Easy / Intermediate / Advanced |
| 🌐 `source` | string | Source website (KitchenAid) |
| 🕒 `scrapedAt` | string | ISO timestamp |
| ❌ `error` | string | Error message (if any) |

**Sample record:**

```json
{
    "imageUrl": "https://images.ctfassets.net/9hu0xqamys79/.../pasta-envy.jpg",
    "title": "Pasta Envy",
    "url": "https://www.kitchenaid.com/countertop-appliances/recipes/pasta-envy",
    "totalTime": 60,
    "servings": 4,
    "ingredients": [
        "1 tablespoon olive oil",
        "4 cloves garlic minced",
        "10 ounces baby spinach",
        "1 ripe avocado",
        "2 tablespoons fresh lemon juice"
    ],
    "tags": ["Pasta", "Blender"],
    "difficulty": "Easy",
    "source": "KitchenAid",
    "scrapedAt": "2026-05-22T01:55:46.872Z"
}
```

### ✨ Why Choose This Actor

- ✅ Real-time data - no cached or stale results
- ✅ Full ingredient lists with amounts and units
- ✅ Difficulty level and course tags included
- ✅ Automatic pagination - just set `maxItems`
- ✅ Clean JSON/CSV/Excel export
- ✅ No login or API key required
- ✅ Free tier available (10 items preview)

### 📈 How It Compares to Alternatives

| Feature | This Actor | Manual scraping | Other scrapers |
|---|---|---|---|
| Real-time data | ✅ | ✅ | varies |
| Structured ingredients | ✅ | manual work | rarely |
| Pagination | ✅ | tedious | varies |
| Difficulty level | ✅ | manual | rarely |
| Setup time | < 1 min | hours | minutes |

### 🚀 How to Use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 free credit)
2. Open the **Yummly Recipe Scraper** actor
3. Enter your search query (e.g., `pasta`, `chocolate cake`)
4. Set `maxItems` to control how many recipes to return
5. Click **Run** and download your dataset as JSON, CSV, or Excel

### 💼 Business Use Cases

#### Meal Planning Apps

Build ingredient-aware meal planners by importing structured recipes with serving sizes and cook times directly into your database.

#### Nutrition Research

Analyze ingredient frequency, dietary patterns, and recipe complexity across thousands of real-world tested recipes.

#### Recipe NLP Datasets

Train food entity recognition, ingredient parsing, or recipe classification models using the structured ingredient and tag data.

#### Culinary Content Creation

Quickly build recipe roundups, "best pasta recipes" articles, or comparison content using bulk-exported recipe data.

### 🔌 Automating Yummly Recipe Scraper

Connect this actor to Make, Zapier, or Slack using Apify's integrations:

- **Make (Integromat)** - trigger runs on a schedule and send new recipes to Google Sheets or Notion
- **Zapier** - pipe new recipe data into Airtable or Mailchimp
- **Slack** - get daily recipe suggestions posted to your team channel
- **Google Sheets** - auto-populate a recipe database with fresh data

### 🌟 Beyond Business Use Cases

#### Academic Research

Food science researchers can analyze ingredient co-occurrence, dietary patterns, and recipe complexity at scale.

#### Creative Projects

Generate recipe variation ideas, build a personal cookbook database, or power a recipe recommendation chatbot.

#### Non-profit and Community

Build free community recipe databases or food bank ingredient guides using public recipe data.

#### Experimentation

Test hypothesis about recipe trends - which ingredients appear together, how difficulty correlates with cook time, etc.

### 🤖 Ask an AI Assistant About This Scraper

Not sure how to use the data? Ask any AI assistant:

> "I have a dataset of recipes in JSON format with title, ingredients, totalTime, servings, difficulty, and tags. How do I build a meal planner from this?"

### ❓ Frequently Asked Questions

**What happened to Yummly.com?**
Yummly was acquired by Whirlpool/KitchenAid. The Yummly domain (yummly.com) now permanently redirects to KitchenAid's recipe section at kitchenaid.com/recipes. All recipe content is intact.

**Does the scraper require login?**
No. All recipe data is publicly available - no account or API key needed.

**How many recipes are available?**
Over 1,500 recipes are indexed, covering all categories from pasta to baking, soups, salads, and desserts.

**Can I filter by category or dietary type?**
Use the `searchQuery` field to filter by keyword. For example: "vegan", "gluten free", "Italian", "chicken", "chocolate".

**Are ingredients structured or just plain text?**
Ingredients are returned as structured strings with amount, unit, and name combined (e.g., "2 cups all-purpose flour").

**Does it include nutrition information?**
The source site does not expose calorie or macro data in its recipe pages, so nutrition fields are not available.

**Does it include ratings?**
KitchenAid's recipe pages do not expose user ratings, so this field is not included.

**How fast does it run?**
Each recipe requires one detail page fetch for servings. At 10 items it runs in under 30 seconds; at 100 items expect 3-5 minutes.

**Is the data updated in real time?**
Yes. Every run fetches live data from the source - no caching.

**What export formats are available?**
JSON, CSV, Excel, XML, and RSS - all available from the Apify dataset view.

### 🔌 Integrate with Any App

Apify connects this scraper to 1,500+ apps via native integrations:

**Productivity:** Google Sheets, Notion, Airtable, Coda
**Automation:** Make, Zapier, n8n
**Storage:** Amazon S3, Google Drive, Dropbox
**Communication:** Slack, Discord, Email
**Database:** PostgreSQL, MySQL, MongoDB
**BI Tools:** Power BI, Tableau, Looker

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [BBCGoodFood Scraper](https://apify.com/parseforge) | Scrape BBC Good Food recipes |
| [AllRecipes Scraper](https://apify.com/parseforge) | Scrape AllRecipes data |
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database |

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

***

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This actor is an independent tool, not affiliated with, endorsed by, or sponsored by Yummly, KitchenAid, or Whirlpool. It accesses only publicly available recipe data. Use responsibly and in accordance with the site's terms of service.

# Actor input Schema

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

Search term for recipes (e.g. 'pasta', 'chicken', 'chocolate cake'). Leave empty to scrape all recipes.

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

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

## Actor input object example

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

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

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

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/yummly-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "pasta",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/yummly-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "pasta",
  "maxItems": 10
}' |
apify call parseforge/yummly-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yummly Scraper | Personalized Recipes Database",
        "description": "Extract recipes from Yummly with ingredients, instructions, prep and cook times, servings, nutrition, ratings, cuisine, and dietary tags. Filter by diet, allergy, or ingredient to power recipe apps, meal planners, food platforms, and AI cooking assistant training datasets.",
        "version": "0.1",
        "x-build-id": "d7GQs4SZL7qWazkBB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~yummly-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-yummly-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~yummly-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-yummly-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~yummly-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-yummly-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term for recipes (e.g. 'pasta', 'chicken', 'chocolate cake'). Leave empty to scrape all recipes."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```