# TheMealDB Recipes Scraper (`ninhothedev/themealdb-scraper`) Actor

$0.5/1K 🔥 Fast TheMealDB recipes scraper! Meals by name, category, area or ingredient — full ingredients & instructions. No key. JSON, CSV, Excel or API in seconds. Pull thousands for recipe apps & food datasets ⚡

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

## Pricing

from $0.50 / 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.

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

## TheMealDB Recipes Scraper 🍽️

Scrape structured **recipe data** from [TheMealDB](https://www.themealdb.com/) — meals with full **ingredients + measures**, step-by-step **instructions**, **categories**, **cuisines (areas)**, tags, thumbnail images and YouTube links. Search by meal name or filter by category, area or main ingredient. **No API key required.**

Perfect for building recipe apps, food datasets, meal-planning tools and content pipelines.

***

### ✨ What it does

- **Search by name** — pass queries like `chicken`, `pasta`, `curry` and get full meals back.
- **Filter by category / area / ingredient** — e.g. all `Seafood` meals, all `Italian` dishes, or everything made with `chicken_breast`.
- **Full enrichment** — filtered results are slim by default on TheMealDB; enable `enrichFull` to fetch complete ingredients, measures and instructions for every match.
- **Clean, normalized output** — the messy `strIngredient1..20` / `strMeasure1..20` fields are paired into a single tidy `ingredients` list and tags are split into an array.

### 📤 Output

One dataset item per meal:

| Field | Description |
|-------|-------------|
| `id` | TheMealDB meal id |
| `name` | Meal name |
| `category` | Category (e.g. Seafood, Dessert) |
| `area` | Cuisine / area (e.g. Italian, Indian) |
| `instructions` | Cooking steps (capped at 6000 chars) |
| `thumbnail` | Meal image URL |
| `tags` | List of tags |
| `youtube` | YouTube tutorial link |
| `source_url` | Original recipe source |
| `ingredients` | List of `"measure ingredient"` strings |
| `source` | Always `themealdb` |
| `scraped_at` | ISO timestamp |

```json
{
  "id": "52795",
  "name": "Chicken Handi",
  "category": "Chicken",
  "area": "Indian",
  "instructions": "Take a large pot or wok...",
  "thumbnail": "https://www.themealdb.com/images/media/meals/wyxwsp1486979827.jpg",
  "tags": [],
  "youtube": "https://www.youtube.com/watch?v=IO0issT0Rmc",
  "source_url": null,
  "ingredients": ["1.2 kg Chicken", "5 thinly sliced Onion", "..."],
  "source": "themealdb",
  "scraped_at": "2026-07-20T12:00:00+00:00"
}
```

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | select | `search` | `search` (by name) or `filter` (by category/area/ingredient) |
| `queries` | array | `["chicken","pasta"]` | Meal name queries (mode=search) |
| `filterType` | select | `category` | `category`, `area` or `ingredient` (mode=filter) |
| `filterValue` | string | – | Value to filter by, e.g. `Seafood` |
| `enrichFull` | boolean | `true` | Look up full details for filtered results |
| `maxItems` | integer | `100` | Max meals to output (max 1000) |

#### Example — search

```json
{ "mode": "search", "queries": ["chicken", "curry"], "maxItems": 50 }
```

#### Example — filter by category with full data

```json
{ "mode": "filter", "filterType": "category", "filterValue": "Seafood", "enrichFull": true }
```

### 💰 Pricing

Pay-per-result, roughly **$0.5 per 1,000 meals**. TheMealDB is datacenter-friendly, so runs are fast and cheap — no residential proxies needed.

### 🎯 Use cases

- **Recipe apps** — seed your app with structured, ready-to-use recipes.
- **Food datasets** — build ML / analytics datasets of meals, ingredients and cuisines.
- **Meal planning** — power weekly planners and shopping-list generators.
- **Content** — food blogs, newsletters and social pipelines.

### 🔗 Related actors

- [Recipe Scraper](https://apify.com/ninhothedev/recipe-scraper)
- [Cocktail Scraper](https://apify.com/ninhothedev/cocktail-scraper)
- [Open Food Facts Scraper](https://apify.com/ninhothedev/open-food-facts-scraper)
- [UPC Barcode Lookup Scraper](https://apify.com/ninhothedev/upc-barcode-lookup-scraper)

### 🏷️ Keywords

themealdb, recipe scraper, meal data, food api, ingredients, cooking, recipe api, meal dataset, cuisine, food scraper

***

*Data sourced from the public TheMealDB API. Use responsibly and in line with TheMealDB's terms.*

# Actor input Schema

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

How to fetch meals. 'search' looks up full meals by name query. 'filter' lists meals by category, area or ingredient.

## `queries` (type: `array`):

Meal name queries used when mode='search' (e.g. 'chicken', 'pasta'). Each returns full meals with ingredients and instructions.

## `filterType` (type: `string`):

Which dimension to filter by when mode='filter'.

## `filterValue` (type: `string`):

Value to filter by when mode='filter' (e.g. 'Seafood' for category, 'Italian' for area, 'chicken\_breast' for ingredient).

## `enrichFull` (type: `boolean`):

When mode='filter', look up each meal id to fetch full details (ingredients, instructions, tags). If false, only slim data (id, name, thumbnail) is returned.

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

Maximum number of meals to output across all queries/filters.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "chicken",
    "pasta"
  ],
  "filterType": "category",
  "filterValue": "Seafood",
  "enrichFull": true,
  "maxItems": 100
}
```

# 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 = {
    "queries": [
        "chicken",
        "pasta"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ninhothedev/themealdb-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 = { "queries": [
        "chicken",
        "pasta",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ninhothedev/themealdb-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 '{
  "queries": [
    "chicken",
    "pasta"
  ]
}' |
apify call ninhothedev/themealdb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/MXXSrtKBRQNCw5xHo/builds/ifW8WTXiOVNfOupr1/openapi.json