# Delish Recipe Scraper (`crawlerbros/delish-recipe-scraper`) Actor

Scrape delish.com for popular recipes.

- **URL**: https://apify.com/crawlerbros/delish-recipe-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Delish Recipe Scraper

Scrape **Delish.com** for trending recipes and cooking ideas. Search by keyword and category, or fetch specific recipes directly by URL — get full ingredient lists, step-by-step instructions, nutrition facts, ratings, dietary tags, and optionally reader reviews and comments. No API key or login required.

### What this actor does

- **Two modes:** `search` (keyword/category search) and `byUrl` (fetch specific recipe pages)
- **Rich filters:** cuisine, minimum rating, dietary tags, max total time, max ingredient count
- **Full recipe detail:** ingredients, step-by-step instructions, nutrition facts, prep/cook/total time, servings
- **Optional reader content:** star reviews and unrated comments/Q\&A, off by default to keep output compact
- **Empty fields are omitted** — a recipe missing a value (e.g. no listed calories) simply won't have that key in the output

### Output per recipe

- `title`, `description`
- `author`, `authorUrl`, `authorTitle`, `authorImageUrl`, `authorBio`, `authorEmail` — recipe developer details
- `prepTime`, `cookTime`, `totalTime`, `servings`
- `ingredients[]`, `ingredientCount`
- `instructions[]`, `stepCount`
- `calories`, `fat`, `saturatedFat`, `transFat`, `cholesterol`, `sodium`, `carbohydrates`, `fiber`, `sugar`, `protein` — nutrition per serving
- `rating`, `ratingCount`, `commentCount`
- `categories[]`
- `cuisine`, `cuisines[]` — primary cuisine, plus the full list when a recipe has more than one
- `keywords[]` — SEO keywords/tags (up to 10)
- `dietaryTags[]` — dietary attributes as tagged by Delish (e.g. vegan, gluten-free)
- `collections[]` — editorial collections/roundups the recipe is featured in (when tagged)
- `imageUrl`, `thumbnailUrl`
- `isSponsored` — whether Delish tagged the recipe as sponsored content
- `sourceUrl` — canonical Delish recipe URL
- `datePublished`, `dateModified`
- `reviews[]` — reader-submitted star reviews (author, rating, text, date) — only present when `includeReviews` is enabled
- `comments[]` — unrated reader comments/Q\&A (author, text, date, upvoteCount, downvoteCount) — only present when `includeComments` is enabled
- `recordType: "recipe"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (keyword/category search) or `byUrl` (fetch direct recipe URLs) |
| `query` | string | `pasta` | Recipe search keyword, e.g. `pasta`, `tacos`, `brownies` (mode=search) |
| `category` | string | – | Recipe category: `chicken`, `beef`, `vegetarian`, `desserts`, `breakfast`, `quick-easy`. Combined with `query` as an additional keyword (mode=search) |
| `sortBy` | string | `relevance` | `relevance` or `recent` (most recently published first). Search mode only |
| `cuisine` | string | – | Filter by cuisine type, e.g. `Italian`, `Mexican` |
| `minRating` | number | – | Minimum recipe rating (1.0–5.0) |
| `maxCookTimeMinutes` | integer | – | Only include recipes with total time (prep + cook) at or under this many minutes (5–480) |
| `maxIngredientCount` | integer | – | Only include recipes with at most this many ingredients (1–50) |
| `dietary` | array | `[]` | Only include recipes tagged with ALL selected dietary attributes: `vegan`, `vegetarian`, `gluten-free`, `dairy-free`, `nut-free`, `healthy`, `heart-healthy`, `low sugar`, `low-carb`, `low-fat`, `low-calorie`, `low-cost`, `kosher`, `paleo diet`, `contains meat` |
| `includeReviews` | boolean | `false` | Include reader-submitted star reviews (author, rating, text, date) for each recipe |
| `includeComments` | boolean | `false` | Include unrated reader comments/Q\&A (author, text, date, upvote/downvote counts) for each recipe |
| `startUrls` | array | `[]` | Direct recipe URLs to fetch (mode=byUrl) |
| `maxItems` | integer | `20` | Maximum number of recipes to return (1–500) |

#### Example: search by keyword

```json
{
  "mode": "search",
  "query": "pasta",
  "maxItems": 20
}
```

#### Example: category + dietary + time filters

```json
{
  "mode": "search",
  "query": "dinner",
  "category": "chicken",
  "dietary": ["gluten-free"],
  "maxCookTimeMinutes": 45,
  "minRating": 4.0,
  "maxItems": 30
}
```

#### Example: fetch specific recipes with reviews

```json
{
  "mode": "byUrl",
  "startUrls": [
    "https://www.delish.com/cooking/recipe-ideas/a20101710/creamy-tuscan-chicken-recipe/"
  ],
  "includeReviews": true,
  "includeComments": true
}
```

#### Example: most recent quick & easy recipes

```json
{
  "mode": "search",
  "category": "quick-easy",
  "sortBy": "recent",
  "maxIngredientCount": 8,
  "maxItems": 25
}
```

### Use cases

- **Recipe apps and meal planners** — bulk-import structured recipes with nutrition and timing data
- **Content aggregation** — feed trending recipes into a food blog, newsletter, or app
- **Nutrition tracking tools** — pull per-serving nutrition facts at scale
- **Dietary-focused platforms** — filter recipes by vegan, gluten-free, keto-friendly and other dietary tags
- **Market research** — track which cuisines, ingredients, and recipe types are trending on a major food site
- **SEO/content research** — analyze recipe keywords, categories, and editorial collections

### FAQ

**Is this free to use? Do I need an account or API key?**
No login or API key is required — delish.com is a publicly accessible website.

**How many recipes can I get in one run?**
Set `maxItems` up to 500 per run.

**Can I scrape specific recipe URLs instead of searching?**
Yes — use `mode: "byUrl"` with a `startUrls` array of Delish recipe page URLs.

**Are reviews and comments included by default?**
No, both are off by default to keep output compact. Enable `includeReviews` and/or `includeComments` to include them.

**What's the difference between `reviews` and `comments`?**
`reviews` are star-rated reader submissions (rating + text). `comments` are unrated reader Q\&A/feedback with community upvote/downvote counts.

**Why do some recipes have `cuisines` in addition to `cuisine`?**
Most recipes have a single cuisine, shown as `cuisine`. When Delish tags a recipe with multiple cuisines, `cuisine` holds the first one and `cuisines` lists all of them.

**Why are some fields missing from certain recipes?**
Delish doesn't populate every field for every recipe (e.g. not all recipes have a listed calorie count or dietary tags). Missing fields are simply omitted from the output rather than returned as empty or null.

**Is this affiliated with Delish or Hearst?**
No, this is an independent third-party actor that reads publicly available recipe pages on delish.com.

**How fresh is the data?**
Each run fetches live data directly from delish.com at request time.

# Actor input Schema

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

Scraping mode: search or browse by category

## `query` (type: `string`):

Recipe search keyword.

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

Filter by cuisine type (e.g. Italian, Chinese).

## `minRating` (type: `number`):

Minimum recipe rating.

## `dietary` (type: `array`):

Only include recipes tagged with ALL selected dietary attributes (as tagged by Delish). Leave empty for no dietary filtering.

## `maxCookTimeMinutes` (type: `integer`):

Only include recipes with a total time (prep + cook) at or under this many minutes. Leave empty for no time limit.

## `maxIngredientCount` (type: `integer`):

Only include recipes with at most this many ingredients (handy for quick/simple recipes). Leave empty for no limit.

## `startUrls` (type: `array`):

List of starting URLs to scrape

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

Maximum number of recipes to return

## `includeReviews` (type: `boolean`):

Include reader-submitted star reviews (author, rating, text, date) for each recipe. Off by default to keep output compact.

## `includeComments` (type: `boolean`):

Include unrated reader comments/Q\&A (author, text, date, upvote/downvote counts) for each recipe. Distinct from star reviews. Off by default to keep output compact.

## `sortBy` (type: `string`):

Order search results by relevance (Delish's default ranking) or most recently published first. Only applies in search mode.

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

Recipe category. Combined with the search query as an additional keyword (Delish does not expose a stable category-browsing URL, so this reliably narrows the keyword search instead).

## Actor input object example

```json
{
  "mode": "search",
  "query": "pasta",
  "dietary": [],
  "startUrls": [],
  "maxItems": 20,
  "includeReviews": false,
  "includeComments": false,
  "sortBy": "relevance",
  "category": ""
}
```

# Actor output Schema

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

Dataset of scraped records.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "query": "pasta",
    "dietary": [],
    "startUrls": [],
    "maxItems": 20,
    "includeReviews": false,
    "includeComments": false,
    "sortBy": "relevance",
    "category": ""
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "search",
    "query": "pasta",
    "dietary": [],
    "startUrls": [],
    "maxItems": 20,
    "includeReviews": False,
    "includeComments": False,
    "sortBy": "relevance",
    "category": "",
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "query": "pasta",
  "dietary": [],
  "startUrls": [],
  "maxItems": 20,
  "includeReviews": false,
  "includeComments": false,
  "sortBy": "relevance",
  "category": ""
}' |
apify call crawlerbros/delish-recipe-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/delish-recipe-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FUBRgC6EiXHO6HkiV/builds/8g2giCeFTCTbUwW1o/openapi.json