# Japan Phone Buyback Prices - iPhone, Android, Switch 買取 (`jpopendata/japan-phone-buyback-prices`) Actor

Buyback (買取) prices of iPhones, Android phones, iPads and game consoles from 3 Japanese buyback shops (買取商店, 携帯空間, モバイル一番) in one table: model, capacity, colour, carrier, new/opened/used price, JAN, update date and a cross-shop match key. Unofficial; not affiliated with the shops.

- **URL**: https://apify.com/jpopendata/japan-phone-buyback-prices.md
- **Developed by:** [JP Open Data](https://apify.com/jpopendata) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Japan Phone Buyback Prices (iPhone, Android, iPad, Switch — 3 kaitori shops)

**Type a model name and get the buyback (kaitori, 買取) prices that three Japanese buyback shops pay for it right now — sealed new, opened and used — in one table with model, capacity, colour, carrier, JAN and the shop's update date. Every row carries a cross-shop key (`maker | model | capacity`), and a best-price comparison per model is saved with the run.**

Resellers and trade-in businesses check these shops one by one to find out where a phone sells for the most, or how much they can pay when sourcing. This Actor does it in one run:

| Shop | What it shows | How it is read |
|---|---|---|
| **買取商店** (Kaitori Shouten, kaitorishouten-co.jp) | 新品 (sealed), 新品 開封済 (opened) and 中古 (used) per colour, with JAN, model number, option deductions and the update date | its public product API (one request per 100 listings) |
| **携帯空間** (Keitai Space, keitaispace.co.jp) | 未開封品 (sealed) and the top used price; JAN for many gadgets | its search / category pages (12 listings per page) |
| **モバイル一番** (Mobile Ichiban, mobile-ichiban.com) | sealed and opened new prices, used prices, colour and network-restriction deductions, list date | its search form, then one list per model |

> **Unofficial tool. Not affiliated with 株式会社エルシーエス (買取商店), 株式会社オーアール (携帯空間) or 海峡通信株式会社 (モバイル一番).** It reads only publicly available price pages, requests only URLs that each site's robots.txt allows, sends one request at a time per shop (2–3 s apart) under a hard request budget, and does not try to get around blocks. It extracts **product facts only**: no images, no descriptions, no personal data. The prices are the shops' published reference prices; the shops set the final price after inspecting the item. You are responsible for making sure your own use of the data complies with each site's terms and the law.

***

### Quick start: verified input

```json
{
  "keywords": ["iPhone 17 Pro"]
}
```

This reads all three shops for "iPhone 17 Pro" (which also matches "iPhone 17 Pro Max") and stores about 100 rows — every colour and condition the shops list. It needs about 10 requests and finishes in under a minute. モバイル一番 is reached through an Apify residential proxy in Japan by default (it refuses Apify's datacenter IPs); 買取商店 and 携帯空間 need no proxy. The best price per model and condition is in the key-value store record `COMPARISON`.

#### Common input mistakes

| Wrong | Right | Why |
|---|---|---|
| `"keywords": ["アイフォン17"]` | `["iPhone 17"]` | The shops write model names in Latin letters. |
| `"keywords": ["iPhone 17"]` when you mean only the base model | `["iPhone 17"]` + `"excludeWords": ["Pro", "Air"]` | Matching is by whole words: "iPhone 17" also matches "iPhone 17 Pro" (but never "iPhone 17e"). |
| `"categories": ["android"]` | `"keywords": ["Pixel 10", "Galaxy S25"]` | Whole-category browsing covers `iphone` and `ipad`; everything else is searched by model name. |
| `"shops": ["iosys"]` | `"shops": ["keitaispace"]` | イオシス, じゃんぱら and GEO are not supported (see the FAQ). The run stops right away and lists the valid shops. |
| `"startUrls": ["https://www.mobile-ichiban.com/..."]` | `"keywords": ["iPhone 16"]` | モバイル一番 lists are answers to its search form and have no URL. |

#### Empty results?

- **A keyword matches nothing** when a shop does not buy the model or writes it differently. Try the shorter model name ("Switch 2" instead of "Nintendo Switch 2 本体") or drop the capacity.
- **One shop has rows and another has none**: each shop buys a different range of models; that is normal.
- If nothing matches anywhere, the run still succeeds with `complete: true` and 0 rows, and nothing is charged.

### Output

One row per shop, listing and condition (a real row from the verified run):

```json
{
  "shop": "kaitorishouten",
  "shopName": "買取商店",
  "productName": "iPhone 17 Pro 256GB コズミックオレンジ MG864J/A SIMフリー",
  "maker": "Apple",
  "model": "iPhone 17 Pro",
  "capacity": "256GB",
  "capacityGb": 256,
  "color": "コズミックオレンジ",
  "carrier": "simfree",
  "carrierLabel": "SIMフリー",
  "category": "smartphone",
  "condition": "new",
  "sealed": true,
  "conditionLabel": "新品",
  "priceJpy": 166000,
  "priceAdjustments": [
    { "label": "Appleストア版", "amountJpy": 0 },
    { "label": "キャリア版未開封", "amountJpy": 0 }
  ],
  "jan": "4549995648300",
  "modelNumber": "MG864J/A",
  "shopProductId": "24672",
  "priceUpdatedAt": "2026-10-07",
  "matchKey": "apple|iphone 17 pro|256gb",
  "url": "https://www.kaitorishouten-co.jp/products/detail/24672",
  "query": "iPhone 17 Pro",
  "source": "買取商店 Kaitori Shouten (kaitorishouten-co.jp) buyback price list",
  "sourceUrl": "https://www.kaitorishouten-co.jp/",
  "license": "Publicly available data — unofficial tool; users are responsible for compliance with the source site's terms",
  "retrievedAt": "2026-10-12T21:45:22.528Z"
}
```

- `condition` is `new` or `used`; `sealed` is `true` (unopened), `false` (opened but unused) or `null` (the shop does not say). `conditionLabel` keeps the shop's own wording (`新品`, `新品 開封済`, `未開封品`, `新品 simfree未開封`, `中古品` ...).
- `priceJpy` is the buyback price. 携帯空間's used price is an "up to" price (`～180,500円`).
- `priceAdjustments` lists what the shop states next to the price: 買取商店 options (`{"label": "開封済", "amountJpy": -15000}`, `箱なし −1,000`), モバイル一番 colour or restriction deductions (`{"label": "青、橙", "amountJpy": -3000}`, `{"label": "△", "amountJpy": -10000}` = network restriction △), or a note without amount (`amountJpy: null`).
- `carrier`: `simfree`, `docomo`, `au`, `softbank`, `rakuten`, `ymobile`, `uqmobile`, `overseas`, `wifi` or `null`; `carrierLabel` is the shop's wording.
- `priceUpdatedAt` is the date the shop prints (買取商店 per product, モバイル一番 per list); 携帯空間 shows none (`null`).
- `url` is the listing's page at the shop (モバイル一番 has no product pages: its top page).

**COMPARISON** (key-value store record), one entry per `matchKey` and condition (`new`, `new_opened`, `used`):

```json
{
  "matchKey": "apple|iphone 17 pro|256gb",
  "maker": "Apple", "model": "iPhone 17 Pro", "capacity": "256GB",
  "condition": "used",
  "bestShop": "mobileichiban", "bestShopName": "モバイル一番", "bestPriceJpy": 145000,
  "byShop": { "kaitorishouten": 143000, "keitaispace": 136000, "mobileichiban": 145000 },
  "shops": 3
}
```

`byShop` is the highest price each shop shows for that key and condition, across colours and carrier versions — check the rows before you sell (a colour or a carrier version can be priced differently). A run summary per shop and query (requests, rows, stop reasons) is in `RUN_SUMMARY`.

#### How `matchKey` works

Each shop writes the same phone differently (`iPhone 17 Pro 256GB シルバー MG854J/A SIMフリー`, `iPhone 17 Pro 256GB`, `iPhone 17 Pro 256GB 中古`). The Actor removes colour, carrier wording, model numbers and JAN, normalizes spacing (`iPhone17` → `iPhone 17`) and keeps maker, model and storage: `apple|iphone 17 pro|256gb`. Carrier and colour stay in their own fields. This lines up iPhones, Pixels and other phones named "model + capacity" across the shops. iPads, consoles and accessories are named too differently between shops; use `jan` or `modelNumber` for them where the shop provides one.

### Input

Every field is optional; `{}` runs the Quick start.

- `keywords` — model names, one per line. A row is kept when its listing name contains every word of the keyword as a whole word.
- `categories` — `iphone` and/or `ipad`: every listing of that category at every selected shop (a full daily price list). モバイル一番 reads one list per model (about 40 for iPhone), so allow a few minutes.
- `shops` — `kaitorishouten`, `keitaispace`, `mobileichiban` (default: all three; Japanese names work).
- `startUrls` — shop list URLs: 買取商店 `/products/list?category_id=17`, `/category/1/747`, `/products/detail/27097`; 携帯空間 `/product/?ca=23` or `/product/?kw=...`.
- `makers`, `conditions` (`new` / `used`), `excludeWords` — filters.
- `maxItems` (500) — rows for the whole run. `maxPagesPerShop` (5) — list pages per query at 携帯空間 / 買取商店.
- `proxyConfiguration` — proxy for 買取商店 and 携帯空間; not needed (default: none).
- `residentialProxyConfiguration` — proxy for モバイル一番 (default: Apify RESIDENTIAL, country JP). It refuses Apify's datacenter IPs, so keep it on; one sticky IP per run, never rotation.

### Pricing

Pay per result: each stored row is one result. A run that stores nothing is not charged for results. See the Pricing tab for current prices.

### FAQ

**Which conditions can I compare?** Sealed new (`condition: new`, `sealed: true`), opened-but-unused (`sealed: false`, where 買取商店 and モバイル一番 price it) and used. Used prices assume a good-condition device; the shops lower them after inspection (scratches, battery, network restriction).

**Why are イオシス, じゃんぱら and GEO not included?** イオシス's and GEO's firewalls refuse this Actor's requests although they are honest (イオシス answers its HTTP client with 403, GEO refuses its User-Agent), and the Actor does not disguise itself. じゃんぱら's disclaimer page requires permission for robot-type automated copying of its pages. Only shops whose robots.txt and terms allow automated reading of their price pages, and that answer the Actor's honest requests, are included. (Flea markets such as Mercari are not buyback shops and are out of scope.)

**Why does モバイル一番 make extra requests?** Its search shows 20 listings per page and the next pages cannot be opened without a browser. When a search has more pages, the Actor reads the matching model lists from the shop's own menu instead, so nothing is missed. If something is still out of reach, the run says so (`complete: false` with the reason).

**Why a residential proxy for モバイル一番?** It drops connections from Apify's datacenter IPs and answers the same honest request from a Japanese residential IP. The Actor therefore sends only that shop's requests through Apify's residential proxy (Japan), keeps one IP for the whole run and never rotates. If the very first request is refused, it is retried once on a new IP and then given up.

**What if one shop blocks the run?** That shop is marked with a `stopReason` and is not asked again; the run still succeeds with `complete: false` as long as other shops returned rows. It fails only when nothing at all was stored and a shop stopped.

**Is this data personal?** No. The rows are shop prices for products. No seller, customer, staff or contact data is collected, so there is no personal data under the GDPR or Japan's APPI in the output; you remain responsible for how you use it.

**How do I credit the source?** Every row carries `source`, `sourceUrl` and `license`. Please keep them when you republish, and link back to the shop.

# Actor input Schema

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

Model names to look up, one per line, as the shops write them (Latin letters): "iPhone 17 Pro", "iPhone 16 128GB", "Pixel 10", "Galaxy S25", "Nintendo Switch 2", "AirPods Pro 第3世代". A row is kept only when its listing name contains every word of the keyword as a whole word ("iPhone 17" also matches "iPhone 17 Pro" but not "iPhone 17e"; add a capacity such as "256GB" to narrow it). If keywords, categories and startUrls are all empty, the Quick start keyword is used.

## `categories` (type: `array`):

Optional. Read every listing of a category at every selected shop: "iphone" (all iPhones the shops buy) and/or "ipad". Good for a daily full price list. Takes more requests and time than keywords (モバイル一番 reads one list per model, about 40 for iPhone). For Android phones, consoles and others, use keywords.

## `shops` (type: `array`):

Which shops to read, one per line: kaitorishouten (買取商店), keitaispace (携帯空間), mobileichiban (モバイル一番). Japanese names and the site domains work too. Default: all three. イオシス, じゃんぱら and GEO are not supported (their firewall or terms do not allow this Actor's automated access).

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

Optional. Paste shop list URLs, one per line: 買取商店 https://www.kaitorishouten-co.jp/products/list?category_id=17, /category/1/747 or /products/detail/27097; 携帯空間 https://www.keitaispace.co.jp/product/?ca=23 or /product/?kw=... Every listing of the page is kept (no keyword filter). モバイル一番 has no list URLs — use keywords.

## `makers` (type: `array`):

Optional. Keep only these makers, as the output's maker field writes them: Apple, Google, Samsung, Sony, Sharp, FCNT, OPPO, Xiaomi, Motorola, ASUS, Nintendo, Microsoft, Valve, Huawei, ZTE, Kyocera, Garmin, Meta, Nothing, Lenovo (Japanese names such as アップル or 任天堂 work too). Empty = all makers.

## `conditions` (type: `array`):

Optional. Keep only "new" (新品 / 未使用 / 未開封, including opened-but-unused rows where a shop prices them) and/or "used" (中古). Empty = both.

## `excludeWords` (type: `array`):

Optional. Drop listings whose name contains any of these words (whole words), e.g. "Max" to keep "iPhone 17 Pro" but not "iPhone 17 Pro Max", or "中古".

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

Maximum records stored for the whole run, all shops together (1..100000; values outside are clamped). One model name such as "iPhone 17 Pro" gives about 100 rows across the three shops (each colour / condition is a row). Each stored record is charged.

## `maxPagesPerShop` (type: `integer`):

Upper bound of list pages read per keyword / category at one shop (1..50). 携帯空間 shows 12 listings per page, 買取商店 100. When a query has more pages than this, the run says so (complete=false). モバイル一番 (one list per model) is not affected.

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

Optional proxy for 買取商店 and 携帯空間. Default: no proxy — both answer Apify's servers directly (verified 2026-10-13). If you set one, one sticky session (one IP) is kept per shop for the whole run, never rotation; only if a shop's very first request is refused is it retried once on a fresh session.

## `residentialProxyConfiguration` (type: `object`):

Proxy for モバイル一番, which refuses Apify datacenter IPs (dropped connections, verified 2026-10-13; it answers through a Japanese residential IP). Default: Apify RESIDENTIAL proxies, country JP — billed by Apify as proxy traffic (a list page is about 200 KB). One sticky session for the whole run, never rotation; only a refused first request is retried once on a fresh session. Turning it off makes モバイル一番 fail on Apify.

## Actor input object example

```json
{
  "keywords": [
    "iPhone 17 Pro"
  ],
  "categories": [],
  "shops": [
    "kaitorishouten",
    "keitaispace",
    "mobileichiban"
  ],
  "startUrls": [],
  "makers": [],
  "conditions": [],
  "excludeWords": [],
  "maxItems": 500,
  "maxPagesPerShop": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "residentialProxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}
```

# Actor output Schema

## `records` (type: `string`):

One record per shop, listing and condition: price, model, capacity, colour, carrier, JAN, the shop's update date and the cross-shop matchKey, with source attribution (source, sourceUrl, license, retrievedAt) on every item.

## `comparison` (type: `string`):

Highest buyback price per matchKey (maker | model | capacity) and condition (new, new_opened, used) across the shops, with the price at each shop.

# 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": [
        "iPhone 17 Pro"
    ],
    "categories": [],
    "shops": [
        "kaitorishouten",
        "keitaispace",
        "mobileichiban"
    ],
    "startUrls": [],
    "makers": [],
    "conditions": [],
    "excludeWords": [],
    "maxItems": 500,
    "maxPagesPerShop": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "residentialProxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "JP"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/japan-phone-buyback-prices").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": ["iPhone 17 Pro"],
    "categories": [],
    "shops": [
        "kaitorishouten",
        "keitaispace",
        "mobileichiban",
    ],
    "startUrls": [],
    "makers": [],
    "conditions": [],
    "excludeWords": [],
    "maxItems": 500,
    "maxPagesPerShop": 5,
    "proxyConfiguration": { "useApifyProxy": False },
    "residentialProxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "JP",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/japan-phone-buyback-prices").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": [
    "iPhone 17 Pro"
  ],
  "categories": [],
  "shops": [
    "kaitorishouten",
    "keitaispace",
    "mobileichiban"
  ],
  "startUrls": [],
  "makers": [],
  "conditions": [],
  "excludeWords": [],
  "maxItems": 500,
  "maxPagesPerShop": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "residentialProxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "JP"
  }
}' |
apify call jpopendata/japan-phone-buyback-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpopendata/japan-phone-buyback-prices"
        }
    }
}
```

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/MmrUnVW43uekJZ3su/builds/HbTO49kgP1aichuCd/openapi.json