# Bikez Motorcycle Specs Scraper (`lulzasaur/bikez-scraper`) Actor

Scrape motorcycle specs from bikez.com. Search by make, model, year, or category. Get engine displacement, power, torque, weight, dimensions, fuel capacity, and full technical data from the largest motorcycle database.

- **URL**: https://apify.com/lulzasaur/bikez-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Bikez Motorcycle Specs Scraper

Scrape motorcycle technical specifications from [bikez.com](https://www.bikez.com) — the largest motorcycle database with 42,000+ models from 1894 to present.

### What it does

- **Search mode**: Browse bikes by make (brand), optionally filtering by model name, year, and/or category
- **Specs mode**: Provide direct bikez.com motorcycle page URLs to extract full specs

Extracts specs from the **JSON-LD structured data** embedded in each page plus static HTML fields — no JavaScript rendering needed.

### Input Parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `mode` | string | `search` (browse by make/model/year) or `specs` (direct URLs). Default: `search` |
| `make` | string | Brand name (e.g. Honda, Yamaha, Kawasaki, BMW, Ducati). Required for search mode |
| `model` | string | Model name substring filter (e.g. CBR, R1, GSX-R). Case-insensitive |
| `year` | integer | Filter by year of manufacture (e.g. 2024) |
| `category` | string | Filter by bike type: sport, touring, cruiser, naked bike, enduro, etc. |
| `limit` | integer | Max number of results. Default: 5, max: 1000 |
| `startUrls` | array | List of bikez.com spec page URLs (specs mode only) |
| `proxyConfiguration` | object | Proxy settings (residential recommended) |

### Output Fields

Each result contains:

| Field | Type | Description |
|-------|------|-------------|
| `make` | string | Manufacturer (e.g. "Honda") |
| `model` | string | Model name (e.g. "CBR600RR") |
| `year` | integer | Year of manufacture |
| `category` | string | Bike type (Sport, Touring, Naked bike, etc.) |
| `engineSize` | number | Displacement in cc |
| `power` | number | Engine power in BHP/hp |
| `torque` | number | Torque in Nm |
| `weight` | number | Wet weight in kg |
| `fuelCapacity` | number | Tank capacity in liters |
| `wheelbase` | number | Wheelbase in mm |
| `fuelConsumption` | number | Fuel consumption in L/100km |
| `co2Emissions` | string | CO2 emissions (e.g. "124.1 g/km") |
| `color` | string | Available color options |
| `price` | number | US MSRP in USD |
| `description` | string | Manufacturer description |
| `imageUrl` | string | Motorcycle photo URL |
| `sourceUrl` | string | Source bikez.com page URL |
| `scrapedAt` | string | ISO 8601 timestamp |

### Example Output

```json
{
  "make": "Honda",
  "model": "CBR600RR",
  "year": 2024,
  "category": "Sport",
  "engineSize": 599,
  "power": 118.01,
  "torque": 66,
  "weight": 189.15,
  "fuelCapacity": 18.17,
  "wheelbase": 1369,
  "fuelConsumption": 5.35,
  "co2Emissions": "124.1 g/km",
  "color": "Grand Prix Red Tricolor (red/blue/white)",
  "price": 12199,
  "description": "Designed to give you complete control, the CBR600RR is the ultimate racetrack tool...",
  "imageUrl": "https://bikez.com/pictures/honda/2024/cbr600rr.jpg",
  "sourceUrl": "https://www.bikez.com/motorcycles/honda_cbr600rr_2024.php",
  "scrapedAt": "2024-04-22T10:00:00.000Z"
}
````

### Example Inputs

#### Search Honda CBR models from 2024

```json
{
  "mode": "search",
  "make": "Honda",
  "model": "CBR",
  "year": 2024,
  "limit": 10
}
```

#### Search all Yamaha sport bikes

```json
{
  "mode": "search",
  "make": "Yamaha",
  "category": "sport",
  "limit": 50
}
```

#### Fetch specs for a specific URL

```json
{
  "mode": "specs",
  "startUrls": [
    { "url": "https://www.bikez.com/motorcycles/honda_cbr600rr_2024.php" },
    { "url": "https://www.bikez.com/motorcycles/yamaha_yzf-r1_2024.php" }
  ]
}
```

### How it works

1. **Search mode**: Fetches the brand listing page (`/brand/<make>_motorcycles.php`) which contains all models in a table. Applies make/model/year filters, then enqueues individual spec pages.
2. **Specs mode**: Directly fetches the provided spec page URLs.
3. **Data extraction**: Each spec page contains a `<script type="application/ld+json">` block with a `Motorcycle` schema containing engine specs, weight, fuel data, etc. The price field is parsed from the static HTML table.

### Supported Makes

All 600+ brands in the bikez.com database are supported, including:

- Honda, Yamaha, Kawasaki, Suzuki
- BMW, Ducati, Triumph, KTM
- Harley-Davidson, Indian, Victory
- Aprilia, MV Agusta, Moto Guzzi
- And hundreds more

### Notes

- Most technical specs (engine type, suspension details, brakes, seat height) are loaded dynamically via JavaScript on the site. The scraper extracts key specs from the JSON-LD structured data, which covers the most important fields.
- Price shown is US MSRP at time of listing on bikez.com, not necessarily current market price.
- Wheelbase in JSON-LD is in centimeters; this scraper converts to millimeters.

# Actor input Schema

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

Search for motorcycles by make/model/year/category, or fetch specs for a specific URL.

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

List of bikez.com motorcycle spec page URLs to scrape (e.g. https://www.bikez.com/motorcycles/honda\_cbr600rr\_2024.php). Used when mode is 'specs'.

## `make` (type: `string`):

Motorcycle manufacturer name (e.g. Honda, Yamaha, Kawasaki, BMW, Ducati). Used in search mode.

## `model` (type: `string`):

Filter results by model name substring (e.g. CBR, CBR600, R1). Case-insensitive. Used in search mode.

## `year` (type: `integer`):

Filter results by manufacturing year (e.g. 2024). Used in search mode.

## `category` (type: `string`):

Filter results by bike category. Used in search mode.

## `limit` (type: `integer`):

Maximum number of motorcycles to scrape.

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

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "mode": "search",
  "startUrls": [],
  "make": "Honda",
  "category": "",
  "limit": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "make": "Honda",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/bikez-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 = {
    "make": "Honda",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/bikez-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "make": "Honda",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call lulzasaur/bikez-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lulzasaur/bikez-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bikez Motorcycle Specs Scraper",
        "description": "Scrape motorcycle specs from bikez.com. Search by make, model, year, or category. Get engine displacement, power, torque, weight, dimensions, fuel capacity, and full technical data from the largest motorcycle database.",
        "version": "1.0",
        "x-build-id": "xxhC0uT6gEVKoHPzV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lulzasaur~bikez-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lulzasaur-bikez-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lulzasaur~bikez-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lulzasaur-bikez-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lulzasaur~bikez-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lulzasaur-bikez-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "specs"
                        ],
                        "type": "string",
                        "description": "Search for motorcycles by make/model/year/category, or fetch specs for a specific URL.",
                        "default": "search"
                    },
                    "startUrls": {
                        "title": "Start URLs (specs mode)",
                        "type": "array",
                        "description": "List of bikez.com motorcycle spec page URLs to scrape (e.g. https://www.bikez.com/motorcycles/honda_cbr600rr_2024.php). Used when mode is 'specs'.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "make": {
                        "title": "Make / Brand",
                        "type": "string",
                        "description": "Motorcycle manufacturer name (e.g. Honda, Yamaha, Kawasaki, BMW, Ducati). Used in search mode.",
                        "default": "Honda"
                    },
                    "model": {
                        "title": "Model name (optional filter)",
                        "type": "string",
                        "description": "Filter results by model name substring (e.g. CBR, CBR600, R1). Case-insensitive. Used in search mode."
                    },
                    "year": {
                        "title": "Year (optional filter)",
                        "minimum": 1894,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Filter results by manufacturing year (e.g. 2024). Used in search mode."
                    },
                    "category": {
                        "title": "Category (optional filter)",
                        "enum": [
                            "",
                            "sport",
                            "sport touring",
                            "touring",
                            "custom / cruiser",
                            "trial",
                            "enduro / offroad",
                            "cross / motocross",
                            "super motard",
                            "naked bike",
                            "classic",
                            "scooter",
                            "allround",
                            "speedway",
                            "minibike",
                            "atv"
                        ],
                        "type": "string",
                        "description": "Filter results by bike category. Used in search mode.",
                        "default": ""
                    },
                    "limit": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of motorcycles to scrape.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```