# Cookpad Scraper - Recipes, Ingredients & Steps (`scrapewise/cookpad-scraper`) Actor

Scrape cookpad.com recipes: ingredients with amounts, step-by-step method, tip, servings, photo, author name, dates, saves, reactions and cooksnaps. Search by keyword in Japan, the US, Brazil, Indonesia or Germany, reach past the 10,000-recipe search limit, or paste links. Error rows are free.

- **URL**: https://apify.com/scrapewise/cookpad-scraper.md
- **Developed by:** [Scrapewise Data](https://apify.com/scrapewise) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.28 / 1,000 item delivereds

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

## Cookpad Scraper: recipes with ingredients, steps and counts from Japan, the US, Brazil, Indonesia and Germany

Cookpad Scraper collects **recipes from cookpad.com** without an account or a browser. Each recipe comes back as one
clean row: title, description, every ingredient with its amount, the numbered steps, the cook's tip, servings, the
main photo, the author's display name and profile link, publish and update dates, and the number of saves, reactions
and cooksnaps.

It is built for recipe databases and meal apps, food trend and ingredient research, nutrition and grocery projects,
and datasets for AI training and RAG on cooking.

### At a glance

| What | Price |
|---|---|
| Recipe delivered | **US$ 3.00 per 1,000 recipes** (US$ 0.003 each) |
| Run start | US$ 0.005 per run |

- 500 recipes = **US$ 1.505**.
- Error rows, duplicates, premium recipes and recipes you already received in earlier runs (`onlyNew`) are never
  charged. `maxItems` is a hard cap, and a spending limit set on the run stops it cleanly with everything delivered so
  far.
- **Beyond the search limit:** a single Cookpad search stops after about 10,000 recipes even when the site says it
  has more (its "curry" search lists 100,360 recipes in Japan). This Actor splits a big keyword into slices that never
  overlap, so one run can deliver far more than 10,000 recipes for the same word.

### Quick start

```json
{
  "keywords": ["ナス"],
  "country": "jp",
  "maxItems": 20
}
```

Another country (keywords in that country's language):

```json
{
  "keywords": ["chicken", "pasta"],
  "country": "us",
  "maxItems": 100
}
```

Everything Cookpad Japan has for one word, past the 10,000 limit:

```json
{
  "keywords": ["カレー"],
  "country": "jp",
  "maxItems": 30000,
  "splitSearch": true,
  "includeDetails": false
}
```

Specific recipes or search pages by link:

```json
{
  "startUrls": [
    "https://cookpad.com/jp/recipes/26759158",
    "https://cookpad.com/jp/search/%E3%83%8A%E3%82%B9"
  ]
}
```

With no input at all the Actor runs the Japanese example above (recipes for ナス, eggplant).

### Input

| Field | What it does |
|---|---|
| `keywords` | One search per keyword, in the language of the chosen country. Newest recipes first. |
| `country` | `jp` (default), `us`, `br`, `id` or `de`. |
| `startUrls` | Recipe links (`https://cookpad.com/jp/recipes/<number>`) and search links (`https://cookpad.com/jp/search/<keyword>`). |
| `includeDetails` | On (default): full recipe rows. Off: only id, link and title from the search list, much faster. |
| `splitSearch` | On (default): when you ask for more than about 9,900 recipes for one keyword, the search is split into non-overlapping slices. No effect on smaller requests. |
| `maxItems` | Stop after this many recipes (default 50, 0 = no cap). |
| `onlyNew` | Skip recipes delivered in earlier runs with the same input. Handy for schedules. |
| `proxyConfiguration` | Datacenter connection by default. |

Aliases accepted so inputs written for other tools keep working: `searchQuery`, `query`, `searchTerms`, `urls`,
`limit`, `maxResults`, `countryCode`, `onlyNewItems`.

### Output fields

| Field | What it holds |
|---|---|
| `type` | `recipe` (or `error` on a free error row). |
| `id`, `url`, `country` | Recipe id, link and country site. |
| `title`, `description` | Recipe name and the author's intro. |
| `imageUrl` | Main photo. |
| `servings` | Servings as written (for example "2 servings"). |
| `ingredients`, `ingredientsCount` | Each ingredient with its amount, and how many. |
| `steps`, `stepsCount` | The method, one text per step, in order. |
| `tip` | The author's tip, when there is one. |
| `authorName`, `authorUrl` | Public display name and profile link of the recipe's author. Nothing else about the author. |
| `publishedAt`, `modifiedAt` | Dates (YYYY-MM-DD). |
| `savesCount`, `reactionsCount`, `cooksnapsCount` | How many people saved, reacted to and cooked the recipe (counts only). |
| `sourceQuery` | The keyword or link that found it. |
| `queryTotalOnSite` | How many recipes Cookpad says exist for that search. |
| `scrapedAt`, `errorCode`, `error` | When it was read, and error details on error rows. |

With `includeDetails` off, only `id`, `url`, `title`, `country`, `sourceQuery` and `queryTotalOnSite` are filled.

### Example output

One recipe from the first quick start (`ナス`, Japan):

```json
{
  "type": "recipe",
  "id": "26733248",
  "url": "https://cookpad.com/jp/recipes/26733248",
  "country": "jp",
  "title": "茄子だけで！ご飯が進み[茄子の生姜焼き]",
  "description": "ティックトックで取り込み保存に成功したレシピです。最近は余り取り込み保存出来ていないので数少ない貴重なレシピです。ポイ活も面倒くさくて余り出来ていないので投稿よりも以前のように、つくれぽばかりになりそうです。おろし生姜は私はチューブの生姜を代用しております😊♥",
  "imageUrl": "https://img-global-jp.cpcdn.com/recipes/57a8e86cb341b8a5/1360x1562f0.5_0.5_1.0q80/%E8%8C%84%E5%AD%90%E3%81%A0%E3%81%91%E3%81%A7%E3%81%94%E9%A3%AF%E3%81%8C%E9%80%B2%E3%81%BF%E8%8C%84%E5%AD%90%E3%81%AE%E7%94%9F%E5%A7%9C%E7%84%BC%E3%81%8D-%E3%83%AC%E3%82%B7%E3%83%94-%E3%83%A1%E3%82%A4%E3%83%B3-%E5%86%99%E7%9C%9F.jpg",
  "servings": "2〜4人分",
  "ingredients": [
    "茄子 3本 ３本（長茄子なら2本）",
    "ごま油 大さじ3〜4",
    "片栗粉 大さじ1弱",
    "水 大さじ1と1/2",
    "醤油 大さじ1と1/2",
    "みりん 大さじ1と1/2",
    "砂糖 大さじ1/2",
    "すりおろし生姜 1片分"
  ],
  "ingredientsCount": 8,
  "steps": [
    "茄子を斜め切りにして水に3〜5分程さらす。",
    "その間に(A)を混ぜ合わせてタレを作る。",
    "茄子の水気をキッチンペーパーなどで拭う。茄子の表面に片栗粉を薄くまぶす。",
    "フライパンにごま油をしき、中火で茄子を炒める。",
    "両面に焼き色がついたら、タレを回しかけて茄子と絡める。",
    "器に盛り付けて完成です。"
  ],
  "stepsCount": 6,
  "tip": "工程5の時にフライパンに油が残っている場合は綺麗にキッチンペーパーで拭き取って下さい。タレが絡みやすくなります。すぐに食べる場合はアク抜きの工程を省略しても大丈夫です。",
  "authorName": "N S",
  "authorUrl": "https://cookpad.com/jp/users/113587942",
  "publishedAt": "2026-10-19",
  "modifiedAt": "2026-10-19",
  "savesCount": 32,
  "reactionsCount": 17,
  "cooksnapsCount": 0,
  "sourceQuery": "ナス",
  "queryTotalOnSite": 133138,
  "scrapedAt": "2026-10-23T18:01:41Z",
  "errorCode": null,
  "error": null
}
```

### What you can build with it

- **Recipe apps and meal planners:** a clean list of ingredients with amounts and numbered steps for every dish, ready
  to load into a database or a search index.
- **Ingredient and trend research:** count which ingredients appear together, which dishes gain saves and reactions,
  and what home cooks publish each week. Run a keyword on a schedule with `onlyNew` and follow the newest recipes.
- **Grocery, delivery and food-tech projects:** match recipes to products by ingredient, build shopping lists, or
  compare how the same dish is cooked in Japan, the United States, Brazil, Indonesia and Germany.
- **AI training and RAG on cooking:** one row per recipe with plain text ingredients and steps, in five languages.

### How the search limit works

Cookpad shows how many recipes match a word (for example 100,360 for カレー in Japan) but a single search only lets
you page through about 10,000 of them. For bigger pulls, leave `splitSearch` on and set `maxItems` above 9,900. The
Actor then cuts the word into slices (the word plus a common ingredient or dish type, then the word without any of
them). A recipe belongs to exactly one slice, so nothing is delivered or charged twice. Big slices still stop at their
own 10,000, which is why the total can reach tens of thousands of recipes for one word.

For a smaller, sharper dataset skip the splitting and use two or three specific keywords instead, such as `ナス 炒め`.
Several words in one keyword are all required to match.

### Tips

- Use `includeDetails: false` first to see how many recipes a keyword has and to collect ids quickly, then run the
  detailed version on the keywords that matter.
- The newest recipes come first, so a small `maxItems` with `onlyNew` on a daily schedule is the cheapest way to
  follow a topic.
- Keywords must be in the language of the country you picked. A Japanese keyword on the Brazilian site finds few or
  no recipes.
- A link to a search page works too: paste the address of any  page and the Actor reads its recipes.

### Errors

Error rows are free and carry `errorCode`: `INVALID_INPUT` (a field is wrong), `INVALID_URL` (not a Cookpad recipe or
search link), `NOT_FOUND` (the recipe does not exist or was removed), `NO_RESULTS` (the search has no recipes),
`BLOCKED` (the site stopped answering; everything found so far was delivered, run again in a few minutes),
`NOT_REACHED` (the run timeout came first).

### Integrations, scheduling and AI agents

- **Schedules:** run daily or weekly with `onlyNew` on to receive just the new recipes.
- **Export:** download the dataset as JSON, CSV, Excel, XML or HTML from the run page, or read it through the Apify API.
- **No-code tools:** connect to Make, n8n, Zapier or Google Sheets with the Apify integrations and send each recipe
  to your database, spreadsheet or CMS.
- **AI agents:** call the Actor from the Apify MCP server so an assistant can search recipes by ingredient or dish and
  read the ingredients and steps directly.

### FAQ

**How many recipes can I get for one word?** Up to about 10,000 per search, and far more with `splitSearch` on and a
high `maxItems`: the Actor reports in the log and in `queryTotalOnSite` how many recipes the site lists.

**Are premium recipes included?** No. Recipes Cookpad sells as premium are left out and never charged.

**Which languages do I get?** The language of the country site: Japanese, English, Portuguese, Indonesian or German.

**Do you collect comments or cooksnap texts?** No. Only the counts.

**What about the author?** Only the public display name and the profile link that Cookpad shows on the recipe.

### Limitations

- Five country sites are supported: Japan, the United States, Brazil, Indonesia and Germany.
- Premium recipes are skipped.
- Counts of saves, reactions and cooksnaps are 0 when Cookpad shows none.
- Cooking time and nutrition are not shown on the recipe pages, so they are not in the output.
- Keep `maxItems` and the schedule reasonable: the Actor reads at a gentle pace, so a 10,000-recipe run takes hours.

### Changelog

- **23 Oct 2026**: first version.

# Actor input Schema

## `keywords` (type: `array`):

One search per keyword, in the language of the country you pick (for example ナス for Japan, chicken for the United States, frango for Brazil). Each keyword returns recipes newest first.

## `country` (type: `string`):

Which Cookpad country site to search. Keywords and recipes are in that country's language.

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

Recipe links (https://cookpad.com/jp/recipes/<number>) or search links (https://cookpad.com/jp/search/<keyword>). Use this instead of, or together with, keywords.

## `includeDetails` (type: `boolean`):

On: every recipe with ingredients, steps, tip, servings, dates, author name and counts. Off: only the id, link and title from the search list, much faster.

## `splitSearch` (type: `boolean`):

A single Cookpad search stops after about 10,000 recipes even when the site lists more. When you ask for more than that, the search is split into non-overlapping slices so you can reach the rest. Has no effect for smaller requests.

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

Stop after this many recipes. 0 means no cap.

## `onlyNew` (type: `boolean`):

Skip recipes delivered in earlier runs with the same input. Skipped recipes are never charged.

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

Datacenter connection by default.

## Actor input object example

```json
{
  "keywords": [
    "ナス"
  ],
  "country": "jp",
  "includeDetails": true,
  "splitSearch": true,
  "maxItems": 20,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `resultsCsv` (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 = {
    "keywords": [
        "ナス"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapewise/cookpad-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 = {
    "keywords": ["ナス"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapewise/cookpad-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 '{
  "keywords": [
    "ナス"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapewise/cookpad-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapewise/cookpad-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/QvF8yKBYhvTtCveh6/builds/bUNAbAu9I3XRrHhk9/openapi.json