# Goobike Scraper: Japan Used Motorcycles, Prices & Shops (`recordsdata/goobike-scraper`) Actor

Scrape goobike.com, Japan's used motorcycle marketplace: price in yen, make, model, year, mileage, engine size, inspection, condition grades and shop. Filter by prefecture, make, model, price or year. Export CSV, Excel, JSON or XML.

- **URL**: https://apify.com/recordsdata/goobike-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** E-commerce, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.00 / 1,000 motorcycle listings

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

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## Goobike Scraper: Japan Used Motorcycles, Prices and Shops from goobike.com

> Goobike Scraper is an Apify Actor that extracts motorcycle listings from goobike.com, Japan's used motorcycle marketplace. Each row has price in yen, make, model, first registration year, mileage, engine size, inspection status, condition grades, photos and the selling shop. Filter by prefecture, make, model, style, price, year or mileage, then export JSON, CSV or Excel.

The actor reads the same public pages that goobike.com shows to any visitor in Japan, with a small number of requests at a time and a pause between them.

### What can you scrape from Goobike?

On 2026-10-26 a search for Tokyo alone returned 7,520 bikes: 4,054 used, 1,866 new bikes in stock at a shop and 1,600 new bikes built to order. The actor reads all of them, and the other 46 prefectures too.

- **Vehicle listings**: one row per bike with title, make in Japanese and English, model year, first registration year, mileage, engine size, colour, transmission, fuel system, option flags, price, total price with fees and the shop's city. About 50 bikes come from each result page.
- **Ad details** (optional): the exact price in yen, the model code, the inspection and insurance dates, repair history, the five condition grades of the shop's own appraisal, the description, the update date and the last three digits of the frame number.
- **Shops**: one row per dealer with review score and count, stock size, opening hours, holiday, founding month, staff count, business description, qualifications and memberships.
- **Price changes**: with the monitor switched on, a bike whose price moved since your last run comes back with the old price, the new price and the difference.

### Why use this Goobike scraper?

- **It works from anywhere**: goobike.com only answers to Japanese internet addresses, so a normal scraper never gets a page. This actor routes every request through a Japanese connection and you do not set up any proxy yourself.
- **Real filters**: prefecture, make, model, bike style, engine size class, condition, price, year, mileage, six option flags, transmission, fuel system and sort order. The site applies most of them itself, so you download only matching bikes.
- **Typed, clean output**: numbers are numbers, dates are ISO 8601 and missing values are left out.
- **Privacy built in**: private sellers do not appear on goobike.com listings, and the shop's street address and phone are output only when you ask for them.

### How to scrape Goobike in four steps

1. Choose **What to collect** on the actor page: a search or a list of addresses.
2. Add prefectures, makes and models, for example `Tokyo`, `Honda` and `CB400`, and set any price, year or mileage bounds.
3. Set **Maximum items** and click **Start**.
4. Download the dataset from the **Storage** tab as JSON, CSV, Excel or XML.

### Two ways to collect data

| Mode (`mode`) | Use it to | Record types |
|---|---|---|
| `search` | Find bikes by place, make, model, style and the full filter set | `vehicle`, `vehicle-detail`, `dealer` |
| `urls` | Read known ads, shops or a goobike.com result page you built by hand | `vehicle-detail`, `dealer`, `vehicle` |

Switch on **Add ad details** and every `vehicle` row becomes a `vehicle-detail` row with the exact price, the condition report and the description. Switch on **Add one row per shop** to receive a `dealer` row for each shop in the results, read once even if it sells fifty bikes.

### What data do you get from Goobike?

The dataset schema lists 77 fields, grouped below. Fields the site does not show for a bike are left out of its row.

| Group | Field |
|---|---|
| Identity | `listingId`, `url`, `title`, `imageUrl`, `recordType`, `sourceSite` |
| Bike | `make`, `makeEn`, `genre`, `condition`, `modelYear`, `firstRegistrationYear`, `mileageKm`, `engineCc`, `color`, `transmission`, `fuelSystem`, `features`, `badges` |
| Price | `price`, `priceManYen`, `currency`, `totalPrice`, `warrantyPlanTotalPrice`, `priceOnRequest`, `previousPrice`, `priceChange` |
| Condition (detail) | `modelCode`, `inspectionStatus`, `shakenUntil`, `insuranceUntil`, `repairHistory`, `appraisalEngine`, `appraisalExterior`, `appraisalFrame`, `appraisalSuspension`, `appraisalElectrics`, `conditionNotes`, `description` |
| Place | `prefecture`, `prefectureCode`, `city` |
| Shop | `dealerId`, `dealerName`, `dealerUrl`, `dealerRating`, `dealerReviewCount`, `dealerStockCount`, `dealerHours`, `dealerHoliday`, `dealerFounded`, `dealerEmployees`, `dealerBusiness`, `dealerQualifications`, `dealerMemberships` |
| Shop contact (on request) | `dealerAddress`, `dealerPostalCode`, `dealerPhone`, `dealerFax`, `dealerWebsite` |

#### Sample output

```json
{
  "recordType": "vehicle",
  "title": "CB400Super ボルドール VTEC Revo NC42 フェンダーレス 81281",
  "listingId": "8502447B30261016002",
  "url": "https://www.goobike.com/spread/8502447B30261016002/index.html",
  "make": "ホンダ",
  "makeEn": "Honda",
  "condition": "used",
  "modelYear": 2016,
  "firstRegistrationYear": 2017,
  "mileageKm": 11796,
  "transmission": "manual",
  "fuelSystem": "injection",
  "price": 828000,
  "priceManYen": 82.8,
  "currency": "JPY",
  "totalPrice": 914700,
  "appraisalEngine": 5,
  "appraisalExterior": 3,
  "prefecture": "東京都",
  "city": "八王子市",
  "dealerName": "リバースオート八王子",
  "dealerRating": 4.7,
  "dealerReviewCount": 189,
  "scrapedAt": "2026-10-26T20:53:55.324Z"
}
```

### Input parameters and filters

| Setting | What it does |
|---|---|
| `prefectures` | One search per prefecture: `Tokyo`, `東京都`, `13`, `Hokkaido` and so on. Empty means all of Japan. |
| `makes`, `models` | One make with one or more models. A partial model name searches every model that contains it. |
| `genres` | Bike style: naked, sport, street, off-road, tourer, American, minibike, scooter, import, adventure and more. |
| `engineClass` | The site's classes: up to 50 cc, 51 to 125, 126 to 250, 251 to 400, 401 to 750, over 750. |
| `conditions` | Used, new in stock, new built to order. |
| `priceMin`, `priceMax` | Yen. The site stores prices in units of 10,000 yen. |
| `yearFrom`, `yearTo` | Year of first registration. |
| `mileageMin`, `mileageMax` | Odometer in kilometres. |
| `features` | One owner, ETC, navigation, security system, unmodified, mail order. |
| `transmission`, `fuelSystem` | Manual or automatic; carburettor or fuel injection. |
| `sort` | Relevance, price, total price, year or mileage, each in both directions. |
| `maxResidentialMB` | Download limit for the run. The run stops cleanly and says so when it is reached. |

```json
{ "mode": "search", "prefectures": ["Tokyo"], "makes": ["Honda"], "models": ["CB400"], "priceMax": 1000000, "yearFrom": 2015, "sort": "price-low", "maxItems": 50 }
```

How the filters behave:

- Price, latest year and maximum mileage are applied by goobike.com. Year-from and minimum mileage cannot be sent to the site, so the actor sorts by year or mileage, stops reading when the values leave your range and checks every row exactly.
- List prices are shown by the site in units of 10,000 yen with two decimals, so a card price is rounded to 100 yen. Switch on **Add ad details** to get the exact price in yen.
- New bikes have no registration year, so a year filter returns used bikes only, and combining it with a new-bike condition is rejected with a clear message.
- `inspectionStatus` is `valid` (the shaken inspection runs until `shakenUntil`), `insurance-only` (only the compulsory insurance runs until `insuranceUntil`), `none` (no inspection) or `no-insurance`.

### Monitor new Goobike listings

Switch on **Only new ads (monitor)** and the actor remembers every bike it delivered, in a named key-value store of your own account. A scheduled run of the same search then returns only unseen bikes, and skipped bikes are never charged. Add **Report price changes** to receive a `changed-listing` row with `previousPrice`, `priceChange` and `priceChangePercent` when a known bike changes price. Give each saved search its own **Monitor name**.

### How much does the Goobike Scraper cost?

Pay per event, no monthly fee. Rates below are in USD per result on the Free tier. Four events exist:

| Event | Charged for | Rate per result | Per 1,000 |
|---|---|---|---|
| `vehicle-record` (default) | One bike taken from the result list, no ad page read | $0.022 | $22.00 |
| `vehicle-detail-record` | One bike with its own ad page read (**Add ad details** on) | $0.044 | $44.00 |
| `dealer-record` | One shop row (**Add one row per shop** on) | $0.022 | $22.00 |
| `changed-listing-record` | One known bike whose price moved (monitor with **Report price changes**) | $0.022 | $22.00 |

A default run costs $22.00 per 1,000 bikes; with ad details it costs $44.00 per 1,000. Error rows, empty searches and ads skipped by monitoring are charged $0. Free Apify plans can read 10 results per run.

### How does Goobike Scraper compare with other scrapers? (read on 2026-10-27)

No actor in the Apify Store was found that targets goobike.com. The niche check of 2026-10-10 searched a dump of the Store by domain and by brand and found none, and this README has not repeated that search since. The nearest references read other vehicle sites in other countries, for example `3x1t/mobile-de-scraper-ppr` for mobile.de and `3x1t/autoscout24-scraper-ppr` for AutoScout24, both European car marketplaces. They do not read Japanese motorcycle ads.

| | Goobike Scraper | Mobile.de and AutoScout24 actors |
|---|---|---|
| Site and country | goobike.com, Japan, JPY | European car sites, EUR |
| Vehicles | Motorcycles and scooters, used and new | Cars |
| Published fields | 77 | Not compared |
| Shop rows, monitor mode, price-change rows | yes | Not checked |

Goobike Scraper does not cover other Japanese portals. It reads only goobike.com, through a Japanese connection it sets up itself.

### Use with AI agents (MCP)

Connect the Apify MCP server to Claude, Cursor or another MCP client and this actor appears as a tool: `https://mcp.apify.com?tools=RecordsData/goobike-scraper`.

Example prompt: "List the 20 cheapest Honda CB400 in Tokyo registered in 2015 or later, with mileage and shop."

### Run it from code

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('RecordsData/goobike-scraper').call({
    mode: 'search',
    prefectures: ['Osaka'],
    makes: ['Yamaha'],
    genres: ['scooter'],
    scrapeDetails: true,
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].price);
```

Call it also from the Python client, Make, Zapier or n8n, or schedule it in the Apify Console.

### Is it legal to scrape Goobike? Risk note and responsible use

Read this before you use the data commercially. The actor reads public pages without logging in, solving a captcha or bypassing any protection, but goobike.com has rules that apply to you as the user of the data.

- **robots.txt**: the file disallows any address that contains `rt=`, `ad=`, `sys=` or `media=` anywhere in its path or query, plus click-tracking scripts, parking pages and the estimate form. The actor never requests them. That is why it never sends the site's own year-from and mileage-from parameters, whose names contain `rt=`, and filters those two bounds itself.
- **Terms of use**: article 1 says the content may be viewed for personal use only, and that showing it to many people for commercial purposes, copying, lending or public transmission is not allowed. Article 2(4) forbids using automated means such as data-collecting bots, robots, spiders or scrapers to access the site.
- **What this means**: automated access may break those terms, and commercial reuse may need the site's permission. You are responsible for your use of the data. Use small runs and check the site terms before republishing commercially.

Privacy: ads on goobike.com come from shops. The actor outputs no private person's data. Shop address, postal code, phone, fax and website are output only when you switch on **Include shop address and phone**, and phone numbers are removed from free texts otherwise.

Limits:

- The site answers only to Japanese addresses, so every page is downloaded through a metered Japanese connection. A result page of 50 bikes is about 35 KB and an ad detail page about 30 KB.

### Frequently Asked Questions

#### How do I scrape goobike.com listings?

Open the actor, keep the mode on `search`, add a prefecture such as Tokyo, a make such as Honda and a model such as CB400, set **Maximum items** and click **Start**. Each result page gives about 50 bikes. To read known ads instead, switch the mode to `urls` and paste addresses like `https://www.goobike.com/spread/<number>/index.html`, a shop page or a result page you built by hand.

#### Do I need a Japanese proxy or an account?

No. goobike.com answers only to Japanese internet addresses, so the actor sends every request through a metered Japanese connection that it sets up by itself. The site needs no login for the pages it reads. If the connection cannot be set up, the run ends with one error row and nothing is charged.

#### Can I search by Japanese or English names?

Yes. Makes and models accept Japanese, Latin letters or the site's own number, and case does not matter, so `Honda`, `ホンダ` and `honda` all work. Prefectures accept Japanese, English or the two-digit code. A name the site does not know returns one free error row that lists the closest matches, so you can correct the spelling and run again.

#### How many bikes can I get in one run?

As many as the search matches, up to the last page the site serves. A broad Tokyo search had 7,520 bikes on 2026-10-26 and 7,500 were read in testing at 50 per page. Free Apify plans are limited to 10 results per run, and paid plans have no such cap.

#### Why does a list price end in 00?

The result pages show prices in units of 10,000 yen with two decimals, so a card price is exact only to 100 yen. The ad detail page shows the exact amount in yen. Switch on **Add ad details** and each bike comes back as a `vehicle-detail` row with the exact `price`, plus the condition report, the inspection dates and the description, at the higher per-result rate shown in the cost section.

#### What do the condition grades mean?

`appraisalEngine`, `appraisalExterior`, `appraisalFrame` and `appraisalSuspension` are the shop's own appraisal grades on the scale that goobike.com uses, and `appraisalElectrics` is a text label. They appear on the ad detail rows of used bikes only. They are the selling shop's opinion, not an independent inspection, so treat them as a hint and check the bike before you buy.

#### Can I get only the ads published since my last run?

Yes. Switch on **Only new ads (monitor)** and schedule the same search. The actor keeps a list of delivered bikes in a named key-value store in your account and returns only unseen ones, and skipped ads are never charged. Add **Report price changes** to also receive a `changed-listing` row with the old price, the new price and the difference. Give each saved search its own **Monitor name**.

#### What happens when the search finds nothing or the input is wrong?

A search with no hits ends with an empty dataset and nothing is charged. An invalid setting, or an unknown make, model or prefecture, gives one error row that says what to fix and suggests the closest names. A sold or removed ad also gives one free error row. Error rows are never billed, so you can test a new search safely.

#### Is it legal to scrape goobike.com?

The pages are public and the actor does not log in or bypass any protection, but the site's terms of use limit automated access and commercial reuse of the content. This is not legal advice. Read the risk note above, keep runs small, and check the site terms before republishing commercially. You are responsible for copyright, database rights and data protection in your own country.

### Support

Questions, a missing field or a feature request: contact.punkrecordsdata@gmail.com.

This actor is an independent tool and is not affiliated with goobike.com or Proto Corporation.

Last updated: 2026-10-27

# Actor input Schema

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

Search motorcycles with the fields below, or paste goobike.com addresses (ads, shops, result pages) in the addresses section.

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

Stops after this many rows (all row types together). Free plan: 10 rows per run. Example: 50.

## `prefectures` (type: `array`):

Where the shop is: Tokyo, Osaka, Hokkaido, 東京都 or code 13. Empty means all of Japan.

## `makes` (type: `array`):

Honda, Yamaha, Suzuki, Kawasaki, Ducati, Harley-Davidson, BMW or Japanese names (ホンダ). Empty means every make.

## `models` (type: `array`):

Models of that make, for example CB400, Rebel 250 or Hornet. A partial name searches every model containing it (up to 24).

## `genres` (type: `array`):

Style as the site sorts them, for example Naked or Sport.

## `engineClass` (type: `string`):

Engine size class of the site, for example 251 to 400 cc.

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

Used, new in stock or new built to order. Empty means used and new together.

## `features` (type: `array`):

Keeps bikes with all ticked features, for example One owner or ETC.

## `transmission` (type: `string`):

Manual (MT) or automatic (AT, scooters).

## `fuelSystem` (type: `string`):

Carburettor or fuel injection (FI).

## `priceMin` (type: `integer`):

Bikes at or above this price in yen, for example 500000.

## `priceMax` (type: `integer`):

Bikes at or below this price in yen, for example 1500000.

## `yearFrom` (type: `integer`):

Gregorian year, for example 2018. Returns used bikes only because new bikes have no registration year.

## `yearTo` (type: `integer`):

For example 2023. Same rules as the from year.

## `mileageMin` (type: `integer`):

Bikes with at least this odometer reading, for example 5000.

## `mileageMax` (type: `integer`):

Bikes with at most this reading, for example 30000. Bikes with no mileage are left out when set.

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

Order of the results, for example Price, lowest first. The year and mileage minimums choose their own order.

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

An ad (https://www.goobike.com/spread/12345/index.html), a shop (https://www.goobike.com/shop/client_123/) or a search result page.

## `scrapeDetails` (type: `boolean`):

Opens each ad: exact price, model code, condition report, description and shop details. Adds one request (about 30 KB) per bike.

## `includeDealerRecords` (type: `boolean`):

Reads each shop page once: hours, founded year, staff, ratings, stock counts. Adds one request per shop; shop rows are charged like others.

## `includeContactDetails` (type: `boolean`):

Adds the shop street address, postal code, phone, fax and website (business data only). Off keeps only prefecture and city.

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

Skips bikes delivered by earlier runs of the same search; skipped rows are not charged.

## `reportPriceChanges` (type: `boolean`):

With Only new ads: a bike seen before whose price changed comes back as a price change row with the old price and difference.

## `stateKey` (type: `string`):

Label to keep several monitors of the same search apart, for example tokyo-honda.

## `resetSeen` (type: `boolean`):

Clears what earlier runs delivered and starts again.

## `maxResidentialMB` (type: `number`):

Safety cap on traffic. The run stops cleanly when reached. About 40 KB per result page of 50 bikes. Example: 10.

## `maxConcurrency` (type: `integer`):

How many ad detail pages are read at once. Requests are also spaced at least 0.4 seconds apart.

## Actor input object example

```json
{
  "mode": "search",
  "maxItems": 10,
  "prefectures": [
    "Tokyo"
  ],
  "makes": [
    "Honda"
  ],
  "models": [],
  "genres": [],
  "engineClass": "any",
  "conditions": [],
  "features": [],
  "transmission": "any",
  "fuelSystem": "any",
  "sort": "relevance",
  "scrapeDetails": false,
  "includeDealerRecords": false,
  "includeContactDetails": false,
  "onlyNew": false,
  "reportPriceChanges": false,
  "stateKey": "",
  "resetSeen": false,
  "maxResidentialMB": 10,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "maxItems": 10,
    "prefectures": [
        "Tokyo"
    ],
    "makes": [
        "Honda"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/goobike-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 = {
    "maxItems": 10,
    "prefectures": ["Tokyo"],
    "makes": ["Honda"],
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/goobike-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 '{
  "maxItems": 10,
  "prefectures": [
    "Tokyo"
  ],
  "makes": [
    "Honda"
  ]
}' |
apify call recordsdata/goobike-scraper --silent --output-dataset

```

## MCP server setup

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