# Melonbooks – Doujinshi & Anime Goods Scraper (`datalab-jp/melonbooks-scraper`) Actor

Scrape doujin goods and otaku merchandise from Melonbooks, a major Japanese doujinshi and character-goods retailer. Get titles, prices, stock, maker, and images as clean JSON, with an option to include or exclude adult (R18) items. Ideal for market research and sourcing. No code.

- **URL**: https://apify.com/datalab-jp/melonbooks-scraper.md
- **Developed by:** [Task Data](https://apify.com/datalab-jp) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.

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

## Melonbooks – Doujinshi & Anime Goods Scraper

Extract **titles, prices, stock status, maker/circle, and images** from [Melonbooks](https://www.melonbooks.co.jp/) — one of Japan's largest retailers of doujinshi (self-published manga), doujin goods, and anime/character merchandise. Built for **international fans, resellers, price researchers, and AI agents** who need structured Japanese doujin-market data without writing a scraper or logging in. No coding required: enter a keyword, run, and get clean JSON.

A key feature is **optional adult (R18) coverage** — Melonbooks sells both all-ages and 18+ doujinshi/goods, and this Actor lets you include R18 listings on demand via a single flag.

### What data can you extract?

| Field | Description |
|-------|-------------|
| `productId` | Melonbooks internal product ID (e.g. `3736438`) |
| `title` | Product title (Japanese) |
| `price` | Current price in Japanese yen (JPY) |
| `listPrice` | Original list price when the item is on a time-sale; `null` otherwise |
| `currency` | Always `"JPY"` |
| `stockLabel` | Stock/availability label, e.g. `予約開始` (reserve open), `完売` (sold out); `null` when simply on regular sale |
| `maker` | Maker or doujin circle name |
| `imageUrl` | Product thumbnail image URL |
| `url` | Direct link to the product detail page |
| `keyword` | The search keyword used for this run |
| `scrapedAt` | ISO 8601 timestamp of when the item was scraped |

### Why scrape Melonbooks?

- **Doujin & otaku merchandise sourcing** — Melonbooks is a core destination for Japanese doujinshi, doujin goods, and limited anime/character event merchandise, much of which is never sold anywhere else.
- **No direct overseas shipping** — because Melonbooks does not ship internationally, fans abroad rely on proxy-shopping services (Buyee, FROM JAPAN, etc.), which makes reliable, structured price and stock data especially valuable for anyone sourcing these items from outside Japan.
- **Restock & release monitoring** — catch new pre-orders, restocks, and limited event goods early.
- **Collector & pricing research** — track pricing history for a series, circle, or character across time-sale discounts.
- **AI agents / RAG** — feed structured Japanese doujin-market data into an LLM workflow. This Actor is discoverable and callable through the [Apify MCP server](https://mcp.apify.com/).

### How to use it (no coding)

1. Click **Try for free / Start**.
2. Enter a **Search keyword** (Japanese works best, e.g. `初音ミク`).
3. Optionally turn on **Include adult (R18) items** to also search 18+ doujinshi and goods.
4. Click **Start** and download the results as JSON, CSV, or Excel — or pull them via the API (below).

### Input example

```json
{
  "searchKeyword": "初音ミク",
  "includeAdult": false,
  "maxItems": 100
}
```

All fields are optional — running with no input uses sensible defaults (keyword `初音ミク`, all-ages only, 100 items).

### Output example

Each result is one product listing:

```json
{
  "productId": "3772082",
  "title": "Vocalodia",
  "price": 2200,
  "listPrice": null,
  "currency": "JPY",
  "stockLabel": "予約開始",
  "maker": "prhythmatiq",
  "imageUrl": "https://melonbooks.akamaized.net/user_data/packages/resize_image.php?width=450&height=450&image=213001049193.jpg&c=0&aa=0",
  "url": "https://www.melonbooks.co.jp/detail/detail.php?product_id=3772082",
  "keyword": "初音ミク",
  "scrapedAt": "2026-08-04T00:22:25.021Z"
}
```

Field notes:

- `listPrice` — only populated when the item is on a time-sale (holds the pre-discount list price); `null` for regular-priced items.
- `stockLabel` — common values include `予約開始` (reserve open), `完売` (sold out), or empty/`null` when the item is simply on normal sale.

### How much does it cost?

This Actor uses **pay-per-event** pricing: a small charge when a run starts, plus a per-result charge for each item returned. You only pay for the data you actually receive, so a 100-item run costs about the price of 100 results. Use `maxItems` to cap your spend.

### Integrations: API, MCP, and AI agents

This Actor is **read-only**: it only reads publicly available product listings and performs no login, purchase, or write actions — safe for autonomous agents to call.

#### API (curl)

```bash
curl -X POST "https://api.apify.com/v2/acts/datalab-jp~melonbooks-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchKeyword": "初音ミク", "includeAdult": false, "maxItems": 50}'
```

> Synchronous runs time out after 300 seconds. For large scrapes, use the standard [run endpoint](https://docs.apify.com/api/v2/act-runs-post) and fetch the dataset afterwards.

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datalab-jp/melonbooks-scraper").call(run_input={
    "searchKeyword": "初音ミク",
    "includeAdult": False,
    "maxItems": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### JavaScript (apify-client)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('datalab-jp/melonbooks-scraper').call({
    searchKeyword: '初音ミク',
    includeAdult: false,
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### MCP / AI agents

This Actor is available through the [Apify MCP server](https://mcp.apify.com/). AI agents (Claude, and any MCP-compatible client) can discover it with `search-actors`, inspect its inputs with `fetch-actor-details`, and run it with `call-actor` — no manual setup on your side.

### Related Actors

Part of a family of **Japanese second-hand & collectibles market** scrapers with consistent, structured output, so you can combine them for cross-marketplace research:

- [**Yahoo! Auctions Sold Scraper**](https://apify.com/datalab-jp/yahoo-auctions-sold-scraper) — sold-price history from Japan's largest auction site
- [**Japan Flea Market Scraper**](https://apify.com/datalab-jp/japan-flea-market-scraper) — Rakuma & Yahoo! Flea Market listings
- [**Mercari Japan Scraper**](https://apify.com/datalab-jp/mercari-japan-listings-scraper) — C2C marketplace listings and sold comps
- [**Suruga-ya Scraper**](https://apify.com/datalab-jp/suruga-ya-scraper) — used hobby goods, figures, and collectibles
- [**CardRush TCG Price Scraper**](https://apify.com/datalab-jp/pokemon-card-price-scraper) — trading card prices across 9 card games (Pokémon, One Piece, etc.)

### FAQ

**Is scraping Melonbooks legal?**
This Actor collects only **publicly available** product listing data by reading Melonbooks' own search result pages — the same pages any visitor sees in a browser. It does not bypass account logins or collect private personal data. You are responsible for using the data in accordance with applicable laws and Melonbooks' terms of service.

**What does "Include adult (R18) items" / `includeAdult` actually do?**
Melonbooks gates its 18+ doujinshi and goods behind an age-verification step. Turning on `includeAdult` (or passing `includeAdult: true` via the API) sets the site's age-confirmation cookie for the run so R18 listings are included alongside all-ages ones. Leaving it off (the default) means the Actor only searches and returns all-ages items — no adult content is ever returned unless you explicitly opt in.

**Can I call this Actor from my own app or API?**
Yes. Use the Apify API or the `apify-client` libraries shown above. Every run returns a dataset you can fetch as JSON, CSV, or Excel.

**Can AI agents use this Actor?**
Yes. It is exposed through the Apify MCP server, so agents can find and run it automatically. It is read-only and safe to call.

**Why does the Actor use a Japanese residential proxy by default?**
Melonbooks refuses Apify's datacenter IPs: in a test on 2026-10-11, five runs through the datacenter proxy returned 0 items (HTTP 403), while three runs through a Japan-based residential proxy returned the results every time. So `proxyConfiguration` defaults to the `RESIDENTIAL` group with country `JP`. A results page is about 560 KB (100 items), so the proxy traffic per run is small. If you set the datacenter proxy yourself and see 0 items, switch back to the default. When a run returns 0 items because of a refused request, the log says so and shows the setting to use.

### Disclaimer

This Actor collects **publicly available** listing data only. It does not collect personal data. Adult (18+) results are opt-in via the `includeAdult` flag and off by default. Use responsibly and in accordance with applicable laws and Melonbooks' terms.

# Actor input Schema

## `searchKeyword` (type: `string`):

Keyword to search on Melonbooks, Japan's largest doujinshi and anime/character goods retailer, e.g. '初音ミク' (Hatsune Miku) or 'ブルーアーカイブ' (Blue Archive). Any plain text is accepted; Japanese keywords return the most results, though some romanized titles and circle names are indexed too. If omitted, the Actor falls back to the default keyword '初音ミク' rather than failing. Each matching product becomes one row in the dataset (one billable result), so pair with `maxItems` to control cost.

## `includeAdult` (type: `boolean`):

Whether to include Melonbooks' adult (18+) doujinshi and goods (e.g. R18 doujin manga or figures) alongside all-ages items. Accepts `true` or `false`; internally this sets the site's age-verification cookie (`AUTH_ADULT=1`) so the search returns 18+ listings instead of being blocked by the age gate. If omitted, defaults to `false` (only all-ages items). Turning it on adds R18 items rather than restricting the search to R18 only; it applies to every page of the run.

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

Maximum number of product listings to return for the run, e.g. `50` for a quick sample or `1000` for a full category sweep. Must be a whole number between 1 and 5000. If omitted, it defaults to 100 items. Each returned item is one billable result, and the Actor automatically paginates through Melonbooks' search results (stopping early if fewer matching items exist than this limit), so this field is the main lever for controlling both run time and cost.

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

Apify Proxy settings for fetching Melonbooks pages, e.g. a Japan-based residential proxy ({'useApifyProxy': true, 'apifyProxyGroups': \['RESIDENTIAL'], 'apifyProxyCountry': 'JP'}) or the datacenter proxy ({'useApifyProxy': true}). Melonbooks refuses Apify's datacenter IPs (HTTP 403, 0 items; tested 2026-10-11), so the default is the Japanese residential proxy; a 100-item page is about 560 KB, so the proxy cost is small. If you choose the datacenter proxy and get 0 items, switch back.

## Actor input object example

```json
{
  "searchKeyword": "初音ミク",
  "includeAdult": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All scraped rows as dataset items (open the dataset to filter, sort, or export to JSON, CSV or Excel).

# 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 = {
    "searchKeyword": "初音ミク",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datalab-jp/melonbooks-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 = {
    "searchKeyword": "初音ミク",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datalab-jp/melonbooks-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 '{
  "searchKeyword": "初音ミク",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}' |
apify call datalab-jp/melonbooks-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datalab-jp/melonbooks-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/Ah3b6fYzkw6YCqG30/builds/eovNEGEbjFylccUIs/openapi.json