# RamenDB Ramen Shops Scraper (`automation-lab/ramendb-ramen-directory-scraper`) Actor

Export public RamenDB ramen shop rankings, prefecture directory records, and selected shop details with stable IDs, locations, ratings, images, hours, and canonical URLs.

- **URL**: https://apify.com/automation-lab/ramendb-ramen-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 1,000 item extracteds

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?

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

## Ramendb Ramen Shops Scraper

Export public **RamenDB ramen shops** as clean, structured records for recurring Japanese food-catalog research.

The Actor reads nationwide rankings, recently popular shops, a prefecture directory, or selected RamenDB URLs. Every result is enriched from the canonical public shop page with stable identity, location, rating, review totals, cuisine, image, coordinates, hours, nearest station, and detail URL.

### What does this RamenDB scraper do?

RamenDB is a Japanese ramen review and directory site.

This Actor turns its public pages into one dataset row per shop.

It supports four practical routes:

1. nationwide overall ranking;
2. recently popular ranking;
3. one prefecture directory;
4. supplied shop, ranking, or prefecture-search URLs.

Ranking records retain their current ranking position.

Shop details come from each canonical page rather than only from a compact listing card.

### Who is this Actor for?

Use it if you are:

- a food researcher comparing notable ramen shops;
- a travel-data team enriching a Japan destination catalog;
- an analyst creating a prefecture-level ramen dataset;
- a directory operator refreshing shop identity and ratings;
- a developer feeding public ramen metadata into a data pipeline;
- an automation specialist scheduling repeatable watchlist refreshes.

The output remains in Japanese where that is how RamenDB publishes it.

### Why use it?

The Actor handles the source-specific work required for useful records:

- Japanese residential routing;
- pagination and stable shop-link discovery;
- bounded retries with a fresh session;
- duplicate removal by canonical shop URL;
- structured detail extraction;
- input validation and explicit failure messages;
- pay-per-result charging only for emitted rows.

You receive a ready-to-export Apify dataset instead of maintaining selectors, proxy geography, and retry logic.

### What RamenDB data can I extract?

| Field | Meaning |
| --- | --- |
| `shopId` | Stable numeric RamenDB shop ID |
| `name` | Public shop name |
| `prefecture` | Japanese prefecture |
| `city` | City, district, or ward |
| `address` | Combined public street address |
| `ratingScore` | Current RamenDB community score |
| `reviewCount` | Published review count |
| `ratingCount` | Published rating count |
| `genre` | Published cuisine categories |
| `imageUrl` | Primary public shop image |
| `canonicalUrl` | Canonical RamenDB shop URL |
| `latitude`, `longitude` | Published coordinates |
| `nearestStation` | Nearest station and displayed distance |
| `openingHours` | Published opening schedule |
| `closedDays` | Published regular closure days |
| `rankingPosition` | Rank for ranking-mode records; otherwise `null` |
| `sourceMode` | `ranking`, `recent`, `prefecture`, or `urls` |
| `scrapedAt` | Extraction timestamp in ISO 8601 format |

Fields unavailable on a shop page are returned as `null` rather than guessed.

### How to scrape RamenDB ramen shops

1. Open the Actor in Apify Console.
2. Choose **Nationwide ranking**, **Recently popular shops**, or **Prefecture directory**.
3. For prefecture mode, enter a lowercase slug such as `tokyo`, `osaka`, `kyoto`, or `fukuoka`.
4. Alternatively, paste public RamenDB shop or listing URLs into **Start URLs**.
5. Set **Maximum shops**.
6. Click **Start**.
7. Open the **Dataset** tab to inspect or export results.

Start with a small limit when evaluating the output.

Increase it for scheduled catalog refreshes after confirming that the selected route matches your job.

### Input parameters

#### `mode`

Selects the discovery route when `startUrls` is empty.

Allowed values:

- `ranking` — nationwide overall ranking;
- `recent` — recently popular ranking;
- `prefecture` — directory for one prefecture.

Default: `ranking`.

#### `prefecture`

A lowercase RamenDB prefecture slug.

It is required when `mode` is `prefecture`.

Examples include `tokyo`, `osaka`, `kyoto`, `hokkaido`, and `fukuoka`.

#### `startUrls`

Optional public URLs on `https://ramendb.supleks.jp`.

Supported paths are:

- `/s/<shop-id>.html`;
- `/rank`;
- `/rank/recent`;
- `/search` with supported public query parameters.

When present, Start URLs take precedence over `mode`.

#### `maxItems`

Maximum unique shops to emit.

Allowed range: 1–1,000.

Default: 20.

### Input examples

Nationwide ranking:

```json
{
  "mode": "ranking",
  "maxItems": 20
}
```

Tokyo directory:

```json
{
  "mode": "prefecture",
  "prefecture": "tokyo",
  "maxItems": 50
}
```

Selected shop watchlist:

```json
{
  "startUrls": [
    { "url": "https://ramendb.supleks.jp/s/77.html" },
    { "url": "https://ramendb.supleks.jp/s/4062.html" }
  ],
  "maxItems": 2
}
```

### Output example

A real shop page produces a record shaped like this:

```json
{
  "shopId": 77,
  "name": "とうかんや",
  "prefecture": "東京都",
  "city": "江東区",
  "address": "東京都江東区南砂5-21-4",
  "ratingScore": 91.603,
  "reviewCount": 144,
  "ratingCount": 216,
  "genre": "ラーメン",
  "imageUrl": "https://s1.spkimg.com/image/2021/03/03/07/1uS7r7kOGbcVDmsD5Asy0jM90fKFnI33.jpg",
  "canonicalUrl": "https://ramendb.supleks.jp/s/77.html",
  "latitude": 35.675290800698,
  "longitude": 139.833709328,
  "nearestStation": "東京メトロ東西線『南砂町駅』（773m）",
  "openingHours": "[月～金] 11:00～15:00／18:00～20:00 [土・祝] 11:00～15:00",
  "closedDays": "日曜、第2・4・5月曜",
  "rankingPosition": null,
  "sourceMode": "urls",
  "scrapedAt": "2026-09-11T14:24:18.461Z"
}
```

Scores, counts, hours, and images can change as RamenDB updates a shop.

### How much does it cost to export RamenDB ramen shops?

The Actor uses pay-per-event pricing.

A run has a **$0.001 start fee** plus a tiered fee for each emitted shop record.

On the BRONZE tier, each item is **$0.0016**.

BRONZE examples use the same formula at every volume:

- 10 useful shops: one start event plus 10 item events;
- 100 useful shops: one start event plus 100 item events;
- 1,000 useful shops: one start event plus 1,000 item events.

Multiply the active per-item tier price by the useful row count, then add the one-time start fee. Apify account-tier discounts apply automatically at larger paid tiers.

Only useful dataset rows trigger the per-item event.

Proxy and compute are included in the Actor workflow; the displayed PPE charge is the customer-facing Actor price.

### Scheduling recurring directory refreshes

Create an Apify Schedule for the same Task input.

For a watchlist, keep stable shop URLs in `startUrls`.

For geographic coverage, schedule one prefecture Task per desired prefecture.

Send each resulting dataset to a database, spreadsheet, webhook, or comparison step.

This Actor returns current snapshots.

It does not calculate historical differences or send change alerts by itself.

### Export and integration options

Dataset results can be downloaded as:

- JSON;
- CSV;
- Excel;
- XML;
- RSS;
- JSONL.

Common workflows include:

- importing shop IDs and coordinates into a destination catalog;
- joining scores to an internal ramen-shop watchlist;
- refreshing a spreadsheet with current review totals;
- comparing scheduled datasets in Make, Zapier, or your own code;
- feeding structured records to a warehouse transformation.

### Use the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ramendb-ramen-directory-scraper/runs?token=YOUR_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{"mode":"prefecture","prefecture":"tokyo","maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ramendb-ramen-directory-scraper').call({
  mode: 'ranking',
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("automation-lab/ramendb-ramen-directory-scraper").call(
    run_input={"mode": "recent", "maxItems": 20}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Keep tokens in environment variables or a secret manager.

### Use with Apify MCP

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/ramendb-ramen-directory-scraper"
```

#### Claude Desktop setup

Use this JSON in Claude Desktop's MCP configuration.

#### Cursor setup

The same remote MCP server URL works in Cursor's MCP settings.

#### VS Code setup

Add the same server object to your VS Code MCP configuration.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ramendb-ramen-directory-scraper"
    }
  }
}
```

Example prompts:

- “Export the current top 20 RamenDB ramen shops.”
- “Build a dataset of 50 RamenDB shops in Tokyo.”
- “Refresh these two RamenDB shop URLs and summarize rating changes against my prior dataset.”

The last prompt requires the client workflow to supply or compare the prior dataset.

### Reliability, retries, and proxy behavior

RamenDB denies ordinary traffic from unsupported regions.

The Actor therefore configures Apify Residential Proxy in Japan automatically.

A failed request is retried once with a fresh coherent session.

The run fails after retry exhaustion instead of silently returning an empty dataset.

Detail requests use bounded concurrency to limit source load and proxy cost.

No browser is used because the required public data is available in server-rendered HTML.

### Limits and responsible use

- Public page structure can change.
- Full-source completeness is not guaranteed.
- `maxItems` is capped at 1,000 per run.
- Source-provided values may be stale, incomplete, or in Japanese.
- Ranking positions reflect the page at extraction time.
- Business hours and closed days should be confirmed before visiting.
- The Actor does not bypass login-only or private data.

Use reasonable limits and schedules.

Avoid aggressive refresh frequencies that provide no business value.

### Legal and ethical use

This Actor extracts publicly displayed business-directory information.

You are responsible for ensuring that your use complies with RamenDB's terms, applicable database rights, privacy rules, and local law.

Do not use the output for harassment, deceptive claims, or unwanted contact.

Respect removal requests and retain only the fields needed for your legitimate purpose.

This documentation is not legal advice.

### Troubleshooting

#### Why did the run reject my URL?

Only HTTPS URLs on `ramendb.supleks.jp` with supported shop, ranking, or search paths are accepted.

Remove unrelated domains and unsupported paths.

#### Why is prefecture mode failing?

Use a lowercase RamenDB slug such as `tokyo`, `osaka`, or `fukuoka`.

Do not enter the Japanese prefecture label in this field.

#### Why did a request fail after retries?

Check the run log for an upstream status or access-denied message.

Retry later rather than launching repeated parallel runs.

If the source changed its page structure, preserve the failing input when reporting the issue.

#### Why are some fields null?

RamenDB does not publish every detail for every shop.

The Actor returns `null` instead of inventing a value.

### FAQ

#### Does the Actor need my RamenDB account or cookies?

No.

It uses public pages and does not require RamenDB login credentials.

#### Can it scrape shops outside Tokyo?

Yes.

Use another supported prefecture slug, a nationwide ranking, or specific public shop URLs.

#### Does it translate Japanese fields?

No.

Source text is preserved to avoid changing names, addresses, and business information.

#### Does it monitor changes automatically?

The Actor creates snapshots.

Use Apify Schedules and a downstream comparison or notification step for monitoring.

#### Can I request more than 1,000 shops?

Run separate bounded prefecture or listing inputs.

The per-run limit protects reliability and source load.

### Related Automation Lab Actors

For broader restaurant discovery, consider the [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) if that public Actor matches your workflow.

RamenDB-specific identity and scoring remain the focus of this Actor.

### Support

When reporting a problem, include:

- the exact input with secrets removed;
- the run URL;
- expected and actual record counts;
- one affected public RamenDB URL;
- the relevant log message.

Do not paste Apify tokens or private credentials into a report.

# Actor input Schema

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

Choose the nationwide overall ranking, recently popular ranking, or one prefecture directory. Supplied Start URLs take precedence.

## `prefecture` (type: `string`):

Required in prefecture mode. Use the lowercase RamenDB slug, for example tokyo, osaka, kyoto, or fukuoka.

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

Optional RamenDB shop, ranking, or prefecture search URLs. When provided, these replace the selected directory mode.

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

Stop after this many unique ramen shop records. Each record includes live detail fields.

## Actor input object example

```json
{
  "mode": "ranking",
  "prefecture": "tokyo",
  "startUrls": [
    {
      "url": "https://ramendb.supleks.jp/s/77.html"
    }
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all extracted ramen shop 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": "ranking",
    "prefecture": "tokyo",
    "startUrls": [
        {
            "url": "https://ramendb.supleks.jp/s/77.html"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ramendb-ramen-directory-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": "ranking",
    "prefecture": "tokyo",
    "startUrls": [{ "url": "https://ramendb.supleks.jp/s/77.html" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ramendb-ramen-directory-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": "ranking",
  "prefecture": "tokyo",
  "startUrls": [
    {
      "url": "https://ramendb.supleks.jp/s/77.html"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/ramendb-ramen-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ramendb-ramen-directory-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/dDtjFuRhj9RxvZ8UA/builds/K3BSWacs4rZacZ8ev/openapi.json