# Food Network Recipes Scraper (`muhammadafzal/food-network-recipes-scraper`) Actor

Scrape Food Network recipes by keyword or URL with ingredients, instructions, nutrition, ratings, times, yields, images, authors, and source links.

- **URL**: https://apify.com/muhammadafzal/food-network-recipes-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (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 $17.00 / 1,000 food network recipes

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Food Network Recipes Scraper

> **Free-plan limit:** Apify free-plan users receive at most 5 delivered records per run. Paid users may use the Actor’s configured result limit.

Search Food Network recipes or scrape specific public FoodNetwork.com pages into structured recipe records for meal-planning apps, recipe databases, food research, content analysis, and AI agents.

The Actor renders public pages in a consistent browser session, discovers recipe URLs from Food Network search/listing pages, and extracts the page’s Schema.org `Recipe` data. It does not return review bodies, private saved recipes, shopping lists, account data, videos, or copyrighted page HTML.

### What it extracts

| Field | Description |
|---|---|
| `sourceUrl`, `name`, `description`, `imageUrl` | Canonical recipe identity and published description/image |
| `author`, `authorUrl` | Chef, contributor, or Food Network Kitchen attribution |
| `rating`, `reviewCount` | Published aggregate rating metadata; no review text |
| `prepTime`, `cookTime`, `totalTime`, `recipeYield` | Published Recipe JSON-LD durations and yield |
| `recipeCategory`, `recipeCuisine`, `keywords` | Categories, cuisines, and topic terms |
| `ingredients`, `instructions` | Ordered ingredient lines and cooking steps |
| `nutrition` | Calories, macros, serving size, sodium, sugar, and related fields when available |
| `datePublished`, `dateModified`, `searchQuery`, `scrapedAt` | Source and run provenance |

### Input

- `searchQuery`: recipe name, ingredient, cuisine, or dish, such as `chicken pasta`. Default: `chicken pasta`.
- `startUrls`: up to 50 public Food Network recipe, category, topic, or search-result URLs. Use an empty `searchQuery` for URL-only runs.
- `maxResults`: 1–100 valid recipe records. Default: `10`.
- `maxPages`: 1–10 listing/search pages followed per discovery route. Default: `3`.
- `includeNutrition`: retain nutrition data when Food Network publishes it. Default: `true`.
- `requestDelayMs`: 500–5000 ms between processed pages. Default: `800`.
- `proxyConfiguration`: defaults to a US residential Apify Proxy session because Food Network commonly rejects non-browser data-center traffic.

Search input:

```json
{
  "searchQuery": "chicken pasta",
  "maxResults": 10,
  "maxPages": 2,
  "includeNutrition": true
}
```

Direct URL input:

```json
{
  "startUrls": [
    { "url": "https://www.foodnetwork.com/recipes/ina-garten/chicken-piccata-recipe-1952866" }
  ],
  "searchQuery": "",
  "maxResults": 1
}
```

### Output example

```json
{
  "sourceUrl": "https://www.foodnetwork.com/recipes/food-network-kitchen/one-pot-cajun-chicken-pasta-8051436",
  "name": "One-Pot Cajun Chicken Pasta",
  "description": "A creamy and comforting one-pot pasta.",
  "imageUrl": "https://food.fnr.sndimg.com/content/dam/images/food/example.webp",
  "author": "Food Network Kitchen",
  "authorUrl": "https://www.foodnetwork.com/profiles/talent/food-network-kitchen",
  "rating": 4.6,
  "reviewCount": 517,
  "prepTime": null,
  "cookTime": "P0Y0M0DT0H30M0.000S",
  "totalTime": "P0Y0M0DT0H30M0.000S",
  "recipeYield": "4 to 6 servings",
  "recipeCategory": ["main-dish"],
  "recipeCuisine": ["american"],
  "keywords": ["Pasta Recipes", "Main Dish", "Chicken Thigh", "Cajun"],
  "ingredients": ["2 tablespoons olive oil", "1 pound boneless, skinless chicken thighs"],
  "instructions": ["Heat the oil in a large pot over medium-high heat."],
  "nutrition": { "calories": "496", "proteinContent": "29g" },
  "datePublished": "2020-01-03T08:17:43.176-05:00",
  "dateModified": "2020-01-03T08:17:42.395-05:00",
  "searchQuery": "chicken pasta",
  "scrapedAt": "2026-08-30T08:00:00.000Z"
}
```

All declared fields are present in every dataset item; unavailable optional values are `null` or an empty array. The default key-value-store `OUTPUT` record classifies the run as `data`, `empty`, `blocked`, `rejected`, or `failed` and includes diagnostics without fabricating recipe rows.

### Pricing

This Actor uses **pay-per-event** pricing. These are the current Apify Store event prices:

| Event | Price (USD) | When it is charged |
|---|---:|---|
| `apify-default-dataset-item` | FREE: $0.02; BRONZE: $0.019; SILVER: $0.018; GOLD: $0.017; PLATINUM: $0.017; DIAMOND: $0.017 | Food Network recipe — One validated public Food Network recipe record written to the default dataset. |
| `apify-actor-start` | $0.01 | Actor Start — Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). — Charged once per run. |

Apify platform usage for this Actor run is included alongside the event prices above; no separate per-run platform-usage fee is passed to users.

This covers Apify platform usage for this Actor run. Other Apify products or usage outside this Actor run may still follow your account plan.

### Reliability and limitations

- Food Network currently exposes search discovery through ItemList JSON-LD and detail data through Recipe JSON-LD. Site markup, bot controls, fields, pagination, and ratings can change.
- The Actor uses one browser worker, persistent cookies, bounded retries, a realistic locale, and a residential proxy session. It does not solve CAPTCHAs or bypass authentication, paywalls, or other access controls.
- Some recipes omit nutrition, preparation time, cuisine, ratings, or author profiles; these fields remain `null` or empty.
- Search ranking and result counts are Food Network’s current results, not a historical or exhaustive catalog.
- Recipe text and images remain the property of their respective owners. Use the output in accordance with Food Network’s terms, robots/access policies, applicable copyright law, and your own legal obligations. Avoid republishing substantial recipe collections without permission.

### API example

Run the Actor through the Apify API or an MCP-compatible Apify client with the same input object shown above, then read `recipes` from the default dataset and `summary` from the `OUTPUT` key-value-store record. The input/output schemas are designed for agent routing and generated API clients.

This Actor is not affiliated with or endorsed by Food Network or Warner Bros. Discovery.

# Changelog

This Actor's version history is a separate document: https://apify.com/muhammadafzal/food-network-recipes-scraper/changelog.md

# Actor input Schema

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

Use for public FoodNetwork.com recipe, topic, category, or search-result URLs. Example: https://www.foodnetwork.com/recipes/ina-garten/chicken-piccata-recipe-1952866. Other domains, authentication, saved recipes, and paywalled pages are not supported.

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

Use to search Food Network by recipe name, ingredient, cuisine, or dish; for example 'chicken pasta'. Defaults to 'chicken pasta'. Set to an empty string when only startUrls should be scraped.

## `maxResults` (type: `integer`):

Maximum valid recipe records to store, from 1 to 100. Each default-dataset record is one automatic recipe-result event. Default: 10.

## `maxPages` (type: `integer`):

Maximum search or listing pages followed per discovery route, from 1 to 10. Direct recipe URLs do not consume this discovery limit. Default: 3.

## `includeNutrition` (type: `boolean`):

Include the public nutrition object when Food Network provides it in Recipe JSON-LD. Default: true.

## `requestDelayMs` (type: `integer`):

Delay between processed pages for a consistent, polite session, from 500 to 5000 milliseconds. Default: 800.

## `proxyConfiguration` (type: `object`):

Use Apify Proxy for rendered Food Network pages. Residential US sessions are recommended; custom proxy URLs are also accepted by the Apify proxy editor.

## Actor input object example

```json
{
  "startUrls": [],
  "searchQuery": "chicken pasta",
  "maxResults": 10,
  "maxPages": 3,
  "includeNutrition": true,
  "requestDelayMs": 800,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `recipes` (type: `string`):

Default dataset items matching the Food Network recipe schema.

## `overview` (type: `string`):

Table view of names, authors, ratings, times, yields, URLs, and source queries.

## `summary` (type: `string`):

OUTPUT record with data, empty, blocked, rejected, or failed status and diagnostics.

# 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": "chicken pasta",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/food-network-recipes-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": "chicken pasta",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/food-network-recipes-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 '{
  "searchQuery": "chicken pasta",
  "maxResults": 10
}' |
apify call muhammadafzal/food-network-recipes-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/food-network-recipes-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/cYGxwoP6x61lSfFbN/builds/i1DxZkk45zWNvjzkp/openapi.json