# Rakuma (Fril) Item Search (`superslowsloth/rakuma-items`) Actor

Search Rakuma - Rakuten's flea market, Mercari's sibling - and get one flat row per item: item id, name, price in JPY, sold flag, brand, thumbnail and the item URL.

- **URL**: https://apify.com/superslowsloth/rakuma-items.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 item scrapeds

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

## Rakuma (Fril) Item Search

Search Rakuma - Rakuten's flea market, Mercari's sibling - and get one flat row
per item: no nested objects, no HTML to strip yourself. Built for a reseller's
new-listing watch or a price check: give it one or more keywords, get back
every matching item's price, sold status, brand and photo.

### Input

| field | meaning |
|---|---|
| `keywords` | One or more searches, exactly as typed into Rakuma's own search box. Every keyword shares the `maxResults` budget below, in the order given |
| `sort` | `relevance` (default), `newest`, `most_liked`, `price_asc`, `price_desc` - Rakuma's own four sort options plus its default |
| `maxResults` | Stop after this many items in total. Rakuma serves 40 per page, so anything up to 40 per keyword is a single page request |
| `proxyConfiguration` | Residential by default - see **Proxy** below |

#### price band and on-sale-only are not input fields, on purpose

Measured 2026-09-28, live against `https://fril.jp/s`: none of `price_min`,
`price_max`, `min_price`/`max_price`, `price_from`/`price_to`,
`price_gte`/`price_lte` changed the result set at all, and no value of
`status` (`on_sale`, `selling`, `sold_out`, `1` through `5`, ...) produced a
clean on-sale-only or sold-out-only split - some landed on Rakuma's plain
homepage instead of search results, others changed the sold/on-sale mix in a
way with no consistent pattern. The checkbox and price-band control visible on
the page are a client-side React component with no URL round trip in the
page's own markup, so there is nothing this actor's input can wire up. Every
row already carries the `sold` flag read straight off the page - filter on
that column after the run instead.

### Output

| field | meaning |
|---|---|
| `item_id` | The 32-character id in the item's own permalink (`item.fril.jp/<id>`) |
| `name` | Listing title |
| `url` | Canonical `item.fril.jp/<id>` link |
| `price_jpy` | Price in yen, always JPY - Rakuma quotes nothing else |
| `sold` | `true` when the card carries Rakuma's "SOLD OUT" ribbon |
| `brand_id`, `brand_name` | Rakuma's brand tag, when the listing carries one |
| `size` | Always `null` - never printed on the search page for any category tried, clothing included |
| `like_count` | Always `null` - the heart button carries no number for a logged-out session |
| `shipping_included` | Always `null` - no shipping badge or caption is printed on the search page at all |
| `thumbnail_url` | The real listing photo (Rakuma's lazy-load placeholder sprite is filtered out) |
| `query` | Which keyword this row came from |

Field names follow Mercari Japan's actor wherever the two sites share a
concept (`query`, `item_id`, `name`, `url`, `price_jpy`, `sold`, `brand_id`,
`brand_name`, `thumbnail_url`), so a Rakuma run and a Mercari run union into
one price-watch table.

#### `null` is not zero

`size`, `like_count` and `shipping_included` are always `null` because Rakuma's
search results page never prints them - not because this actor failed to read
them. A `0` in any of those columns would read as a measurement ("no likes",
"free shipping") when the truth is that the page said nothing at all.

### Paging and sort

Rakuma pages with a single `page` number and orders results with two
parameters together: `sort` names the field, `order` names the direction,
because Rakuma reuses the field name `sell_price` for both "cheapest first"
and "priciest first" and only `order` tells them apart. `newest` maps to
`sort=created_at&order=desc` - the option a new-listing watch wants.

### Proxy

Residential is the default. Measured from a running Actor on 2026-09-28:
Apify's datacenter proxy got HTTP 403 from `fril.jp` on every exit tried (4 of
4, rotating between each), while `RESIDENTIAL` - unpinned, and pinned to
`apifyProxyCountry: "JP"` - returned a full page of results first time. You can
switch to datacenter to cut proxy cost, but expect the run to end with
refusals in the log and no rows.

### Billing

Pay per event, all-in: **$0.0007 per item**, plus **$0.002 actor-start per run**.
Platform usage - compute, bandwidth, proxy - is included; nothing is billed to
you beyond the two event prices above, and nothing is charged twice for the
same item id even when two keywords both turn it up.

For comparison, on the Apify Store: `jungle_synthesizer`'s Rakuma/Fril listings
scraper charges $0.001 per item plus a $0.10 actor-start fee; `youfuxu`'s
charges $0.003 per item. This actor's $0.0007 per item is exactly 30% under the cheaper of the two
($0.001), and its own actor-start fee is $0.002 per run rather than the $0.10
`jungle_synthesizer` charges on top of its per-item price.

# Actor input Schema

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

One or more searches to run, each exactly as you would type it into Rakuma's search box, e.g. "ニンテンドースイッチ" (Nintendo Switch). Japanese and English both work. Every keyword shares the maxResults budget below, in the order given - so if the first keyword alone reaches maxResults, later ones are never searched. Duplicate spellings that differ only in case are collapsed before anything is fetched.

## `sort` (type: `string`):

How Rakuma should order the results before this actor pages through them. "Newest first" is what a new-listing watch wants; "Most liked" and the price sorts are Rakuma's own dropdown options.

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

Stop after this many items in total, shared across every keyword above. Rakuma serves 40 items per page, so anything up to 40 per keyword costs a single page request and each further 40 is one more.

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

Residential is the default. Measured from a running Actor on 2026-09-28: Apify datacenter proxy exits got HTTP 403 from fril.jp on 4 of 4 addresses, while RESIDENTIAL (unpinned, and pinned to JP) returned full results first time. Switching to datacenter will cut proxy cost but expect refusals.

## Actor input object example

```json
{
  "keywords": [
    "ニンテンドースイッチ"
  ],
  "sort": "relevance",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `items` (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": [
        "ニンテンドースイッチ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/rakuma-items").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": ["ニンテンドースイッチ"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/rakuma-items").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": [
    "ニンテンドースイッチ"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call superslowsloth/rakuma-items --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/rakuma-items"
        }
    }
}
```

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/oLjbuTOIZZMZi6bti/builds/ZWfsTRZoKfPg1Jyns/openapi.json