# Buycycle Scraper (`solidcode/buycycle-scraper`) Actor

\[💰 $0.09 / 1K] Extract used bike listings from buycycle.com, Europe's largest used bike marketplace — brand, model, price, MSRP, discount, frame size, year, groupset, condition, e-bike status, seller type, and photos. Search by keyword or filters, or paste a URL.

- **URL**: https://apify.com/solidcode/buycycle-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.09 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Buycycle Scraper

Pull used and refurbished bike listings from buycycle.com at scale — asking price next to original MSRP, calculated discount, condition grade, frame size, model year, groupset, full component specs, seller location, and every listing photo. Built for bike shops sourcing inventory, resellers hunting underpriced frames, and pricing analysts who need the second-hand market as a clean spreadsheet without clicking through thousands of listings one at a time.

### Why This Scraper?

- **29 country storefronts across 10 currencies** — Germany, Switzerland, the US, and 26 more. Each storefront has its own seller pool and prices land in that market's real currency (EUR, CHF, CZK, DKK, HUF, NOK, PLN, RON, SEK, USD).
- **MSRP and discount percentage on every bike** — original retail price sits beside the asking price with the discount already calculated for you. That is the underpriced-listing signal, precomputed on every row.
- **Buycycle's own price rating, plus the common market price** — the marketplace's verdict on whether a listing is priced well, alongside the going rate for comparable bikes. Two independent value benchmarks per listing.
- **23 filters, every one applied at the source** — nothing is filtered after collection, so you never pay for rows that get thrown away. Competing tools bill you for a full crawl and then discard most of it.
- **Full component specs on every listing** — condition, frame material, brake type, shifting (electronic vs. mechanical), colour, wheel size, and suspension type. None of these appear on buycycle's own results grid.
- **Five condition grades** — Fair, Good, Very good, New, and Brand new with warranty, filterable individually.
- **Postcode proximity search from 10 to 300 km** — real distance search around any postcode, not a vague country-level scope.
- **Private sellers vs. shops & dealers** — isolate either side of the market in one toggle, plus a High demand badge filter for listings buyers are actively watching.
- **Up to 10,000 listings per search** — with four sort orders (relevance, newest, lowest price, highest price) so a capped run captures the end of the market you actually care about.

### Use Cases

**Resale & Arbitrage**
- Spot listings priced far below MSRP using the precomputed discount percentage
- Cross-reference asking price against buycycle's common market price for the same model
- Track high-demand badges to find bikes that resell quickly
- Compare the same model across storefronts to find the cheapest source market

**Bike Shop Inventory Sourcing**
- Find trade-in stock near your shop with postcode and radius search
- Source specific frame sizes and model years to fill gaps in your range
- Filter to private sellers for direct-purchase opportunities
- Build buy lists by brand and model family with condition minimums

**Market & Pricing Research**
- Benchmark used prices by brand, category, and model year
- Measure how carbon, aluminium, and titanium frames hold value
- Compare electronic vs. mechanical groupset premiums
- Track price spread across 29 European and US markets

**Deal Monitoring**
- Run scheduled searches sorted by newest to catch listings as they appear
- Watch a single model family for below-market entries
- Alert on discounted listings above a discount threshold
- Monitor a postcode radius for local pickup opportunities

**Competitive Intelligence**
- Map which shops and dealers list the most inventory
- Analyse how commercial sellers price against private sellers
- Track e-bike share of the market by category and country
- Feed second-hand pricing into valuation and trade-in tools

### Getting Started

#### Search by Keyword

The simplest way to start:

```json
{
    "searchQueries": ["Canyon Aeroad"],
    "maxResults": 50
}
````

#### Paste a Buycycle URL

Any shop, search, or individual bike URL works directly:

```json
{
    "startUrls": [
        "https://buycycle.com/en-de/shop/main-types/bikes/brands/specialized"
    ],
    "maxResults": 100
}
```

#### Hunt Discounted Carbon Road Bikes

The most useful filter combination — narrow at the source, sort cheapest first:

```json
{
    "country": "de",
    "categories": ["road"],
    "frameMaterials": ["carbon"],
    "frameSizes": ["m", "l"],
    "conditions": ["very-good", "new"],
    "maxPrice": 3000,
    "minYear": 2021,
    "sortBy": "lowest-price",
    "maxResults": 200
}
```

#### Full-Featured Example

```json
{
    "searchQueries": ["Tarmac SL7"],
    "country": "ch",
    "brands": ["specialized"],
    "families": ["tarmac"],
    "conditions": ["very-good", "new", "brand-new-with-guarantee"],
    "frameMaterials": ["carbon"],
    "brakeTypes": ["disc"],
    "shifts": ["electronic"],
    "minPrice": 2000,
    "maxPrice": 8000,
    "minYear": 2021,
    "postcode": "8001",
    "radiusKm": 100,
    "sellerType": "private",
    "frameset": "complete",
    "highDemandOnly": true,
    "sortBy": "lowest-price",
    "includeFullSpecs": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `["https://buycycle.com/en-de/shop/main-types/bikes"]` | Paste one or more buycycle.com shop, search, or individual bike URLs. When provided, these are used directly and the search fields below are ignored. |
| `searchQueries` | string\[] | `[]` | Free-text searches, for example "Canyon Aeroad". Each keyword is collected separately. Leave empty to browse by filters only. Ignored when URLs are provided. |
| `country` | select | `Germany` | Which buycycle storefront to search. Sets the currency and the pool of sellers that ship to you. 29 options from Germany to the United States. |

#### Search Filters

Every filter is optional — leave a field empty to include everything.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mainTypes` | select\[] | `[]` | Buycycle sells complete bikes as well as gear for other sports. Bikes, Cycling gear & parts, Running, Winter sports, Outdoor, Ball sports, Water sports, Racket sports, Other. Leave empty for complete bikes only. |
| `bikeTypes` | select\[] | `[]` | Road & gravel, Mountain bike, Urban & touring, or Youth. |
| `categories` | select\[] | `[]` | A finer breakdown than bike type — Road, Gravel, Triathlon, Cyclocross, Trail, Enduro, Downhill, Cross country, City, Trekking, Cargo & transport, Vintage, BMX, and more. |
| `brands` | string\[] | `[]` | Only include these brands, e.g. `"canyon"`, `"specialized"`. Lowercase with dashes instead of spaces. |
| `families` | string\[] | `[]` | Only include these model lines, e.g. `"aeroad"`, `"tarmac"`. Works best together with the matching brand. |
| `frameSizes` | select\[] | `[]` | XXXS through XXL, plus One size and Youth. |
| `conditions` | select\[] | `[]` | Fair, Good, Very good, New, or Brand new with warranty. |
| `frameMaterials` | select\[] | `[]` | Carbon, Aluminium, Steel, Titanium, or Magnesium. |
| `brakeTypes` | select\[] | `[]` | Disc, Rim, Drum, Coaster, or Other. |
| `shifts` | select\[] | `[]` | Electronic (Di2, eTap, EPS), Mechanical, or Other. |
| `colors` | select\[] | `[]` | Black, White, Light grey, Blue, Red, Green, Orange, or Purple. |
| `gender` | select | `Any` | Intended rider: Any, Unisex, Men, Women, or Kids. Buycycle applies this to gear and apparel only. |
| `eBike` | select | `Any` | Any, E-bikes only, or Exclude e-bikes. |
| `frameset` | select | `Any` | Any, Complete bikes only, or Framesets only. |
| `sellerType` | select | `Any` | Any, Private sellers, or Shops & dealers. |
| `highDemandOnly` | boolean | `false` | Only return listings carrying buycycle's "High demand" badge. |

#### Price, Year & Location

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minPrice` | integer | — | Lowest price to include, in the marketplace currency. This is the item price, before the buyer protection fee is added. |
| `maxPrice` | integer | — | Highest price to include, in the marketplace currency. |
| `minYear` | integer | — | Only include bikes from this model year or newer (2013–2027). |
| `maxYear` | integer | — | Only include bikes from this model year or older (2013–2027). |
| `postcode` | string | `""` | Find bikes near a postcode, e.g. `"10117"`. Must be a postcode in the marketplace country selected above. |
| `radiusKm` | integer | `50` | How far from the postcode to search. Buycycle supports 10, 25, 50, 100, 150, 200, 250, and 300 km — other values round up to the nearest supported one. |

#### Sorting & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Relevance` | Relevance, Newest listings, Lowest price, or Highest price. Useful with a result limit — sort by lowest price to capture the cheapest bikes first. |
| `includeFullSpecs` | boolean | `true` | Fetch the complete specification for every listing. Adds condition, frame material, brake type, shifting, colour, wheel size, suspension, seller city and country, model family, price rating, and the seller's description. Turn off for a much faster, cheaper run returning only the basics. |
| `maxResults` | integer | `100` | Maximum results per search. Set to 0 for as many as the site will return. Results arrive in pages and the last page is always returned in full, so you may receive slightly more than this number. |

### Output

Here is a representative result with full specifications enabled:

```json
{
    "id": "412887",
    "title": "Specialized Tarmac SL7 Expert",
    "brand": "Specialized",
    "family": "tarmac",
    "url": "https://buycycle.com/en-de/product/specialized-tarmac-sl7-expert-412887",
    "price": 3450,
    "currency": "EUR",
    "totalPriceFormatted": "€ 3,657 incl. buyer protection",
    "msrp": 5500,
    "priceOriginal": 3800,
    "isDiscounted": true,
    "discountPct": 37,
    "condition": "Very good",
    "frameSize": "56 (M)",
    "year": 2022,
    "groupset": "Shimano Ultegra Di2",
    "frameMaterial": "Carbon",
    "brakeType": "Disc",
    "shifting": "Electronic",
    "wheelSize": "700c",
    "suspensionType": "Rigid",
    "color": "Black",
    "receiptAvailable": "Yes",
    "categoryName": "Road",
    "typeName": "Road & gravel",
    "productType": "bike",
    "isHighDemand": true,
    "favoritesCount": 27,
    "sellerCity": "Berlin",
    "sellerCountry": "Germany",
    "priceRating": "Good price",
    "commonPrice": 3900,
    "description": "Ridden two seasons, always stored indoors. Recently serviced...",
    "imageUrl": "https://assets.buycycle.com/example-1.jpg",
    "images": [
        "https://assets.buycycle.com/example-1.jpg",
        "https://assets.buycycle.com/example-2.jpg"
    ],
    "country": "de",
    "searchQuery": "Tarmac SL7",
    "scrapedAt": "2026-07-17T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique buycycle listing identifier |
| `title` | string | Full listing title |
| `brand` | string | Bike brand, e.g. "Specialized" |
| `family` | string | Model family, e.g. "tarmac" |
| `url` | string | Direct link to the listing |
| `year` | number | Model year |
| `frameSize` | string | Frame size as the seller listed it |
| `groupset` | string | Drivetrain / component group, e.g. "Shimano Ultegra Di2" |
| `categoryName` | string | Category, e.g. "Road", "Gravel", "Trail" |
| `typeName` | string | Broader bike type, e.g. "Road & gravel" |
| `productType` | string | Product class, e.g. "bike" |
| `country` | string | Storefront the listing was collected from |
| `searchQuery` | string | Keyword this result came from, when one was used |
| `scrapedAt` | string | ISO timestamp of data extraction |

#### Pricing & Value

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Current asking price in the storefront currency |
| `currency` | string | Currency of the storefront searched |
| `msrp` | number | Original manufacturer retail price, when published |
| `priceOriginal` | number | Seller's previous asking price before any reduction |
| `isDiscounted` | boolean | Whether the seller has reduced the price |
| `discountPct` | number | Percent below MSRP, calculated for you |
| `totalPriceFormatted` | string | Total including buyer protection fee, as buycycle displays it |
| `priceRating` | string | Buycycle's verdict on the price, e.g. "Good price" |
| `commonPrice` | number | Typical market price for comparable bikes |

#### Specifications

Populated when `includeFullSpecs` is on.

| Field | Type | Description |
|-------|------|-------------|
| `condition` | string | Fair, Good, Very good, New, or Brand new with warranty |
| `frameMaterial` | string | Carbon, Aluminium, Steel, Titanium, or Magnesium |
| `brakeType` | string | Disc, Rim, Drum, Coaster, or Other |
| `shifting` | string | Electronic or Mechanical |
| `wheelSize` | string | Wheel size — published mainly on mountain bikes |
| `suspensionType` | string | Suspension setup, where the seller listed one |
| `color` | string | Colour as listed |
| `receiptAvailable` | string | Whether the seller still has the original receipt |

#### Seller & Demand

| Field | Type | Description |
|-------|------|-------------|
| `sellerCity` | string | Seller's city |
| `sellerCountry` | string | Seller's country |
| `isHighDemand` | boolean | Carries buycycle's "High demand" badge |
| `favoritesCount` | number | How many buyers have saved this listing |
| `description` | string | Seller's own description of the bike |

#### Media

| Field | Type | Description |
|-------|------|-------------|
| `imageUrl` | string | Primary listing photo |
| `images` | string\[] | Every listing photo |

### Tips for Best Results

- **Narrow rather than chase the cap** — any single search returns up to 10,000 listings, while the full catalogue runs to roughly 49,000 bikes. To go wider, split the work across several runs partitioned by brand, category, country, or price range.
- **Switch country to widen the pool, not just the currency** — a bike only shows up in the storefronts its seller ships to. The same brand search against Germany, Switzerland, and the US returns three genuinely different result sets.
- **Sort before you cap** — with `maxResults` set, `sortBy` decides which end of the market you keep. Lowest price plus a modest cap is the cheapest way to surface bargains.
- **Find underpriced bikes with `msrp` and `discountPct`** — both ship on every row, so you can rank by discount downstream at no extra cost. Cross-check against `priceRating` and `commonPrice` before committing.
- **"Intended rider" applies to gear and apparel only** — buycycle does not tag bikes by rider category, so combining it with Bikes returns nothing. Leave it on Any for bike searches.
- **Postcodes must match the storefront** — a German postcode only works with the Germany marketplace. Radius rounds up to the nearest supported step (10, 25, 50, 100, 150, 200, 250, or 300 km).
- **Turn off full specifications for a fast, cheap sweep** — great for a price-only sweep, but condition, frame material, brake type, shifting, colour, wheel size, seller location, and description come back empty. Leave it on when specs matter.

### Pricing

**From $0.09 per 1,000 results** — the lowest rate for used-bike listings on the platform, with full specifications included rather than sold as an upgrade. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.0105 | $0.0100 | $0.0095 | $0.0090 |
| 1,000 | $0.105 | $0.100 | $0.095 | $0.090 |
| 10,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 100,000 | $10.50 | $10.00 | $9.50 | $9.00 |

A "result" is one bike listing in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, pricing analysis, and inventory sourcing. Users are responsible for complying with applicable laws and buycycle's Terms of Service. Collect only what you need, and do not use extracted data for spam, harassment, or any illegal purpose. Seller names and contact details are not collected; treat any personal data appearing in listing descriptions in line with GDPR and other applicable privacy rules.

# Actor input Schema

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

Paste one or more buycycle.com shop, search, or individual bike URLs — for example https://buycycle.com/en-de/shop/main-types/bikes or https://buycycle.com/en-de/product/canyon-aeroad-cf-slx. Leave empty to build a search with the filters below instead. A URL wins on any filter it already carries; every other setting you choose still applies on top of it.

## `searchQueries` (type: `array`):

Free-text searches, for example "Canyon Aeroad" or "Specialized Tarmac". Each keyword is collected separately. Leave empty to browse by filters only. Ignored when URLs are provided.

## `country` (type: `string`):

Which buycycle storefront to search. This sets the currency and the pool of sellers that ship to you.

## `mainTypes` (type: `array`):

Buycycle sells complete bikes as well as gear for other sports. Leave empty for complete bikes only.

## `bikeTypes` (type: `array`):

Only include these kinds of bikes. Leave empty for all types.

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

A finer breakdown than bike type, for example gravel, trail, or triathlon. Leave empty for all categories.

## `brands` (type: `array`):

Only include these brands, for example "canyon", "specialized", or "trek". Add one brand per entry, in lowercase with dashes instead of spaces. Leave empty for all brands.

## `families` (type: `array`):

Only include these model lines, for example "aeroad" or "tarmac". Works best together with the matching brand. Leave empty for all models.

## `frameSizes` (type: `array`):

Only include bikes in these frame sizes. Leave empty for all sizes.

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

Only include bikes in these conditions. Leave empty for all conditions.

## `frameMaterials` (type: `array`):

Only include bikes with these frame materials. Leave empty for all materials.

## `brakeTypes` (type: `array`):

Only include bikes with these brakes. Leave empty for all brake types.

## `shifts` (type: `array`):

Only include bikes with this shifting type. Electronic covers Di2, eTap, and EPS; mechanical is cable-operated.

## `colors` (type: `array`):

Only include bikes in these colours. Leave empty for all colours.

## `gender` (type: `string`):

Only include items made for this rider category. Note: buycycle applies this to gear and apparel only — combining it with "Bikes" returns no results.

## `eBike` (type: `string`):

Limit results to electric bikes, or exclude them entirely.

## `frameset` (type: `string`):

Limit results to complete bikes, or to framesets sold without components.

## `sellerType` (type: `string`):

Limit results to private individuals or to professional shops and dealers.

## `highDemandOnly` (type: `boolean`):

Only return listings carrying buycycle's "High demand" badge.

## `minPrice` (type: `integer`):

Lowest price to include, in the marketplace currency. This is the item price, before the buyer protection fee is added.

## `maxPrice` (type: `integer`):

Highest price to include, in the marketplace currency. This is the item price, before the buyer protection fee is added.

## `minYear` (type: `integer`):

Only include bikes from this model year or newer.

## `maxYear` (type: `integer`):

Only include bikes from this model year or older.

## `postcode` (type: `string`):

Find bikes near a postcode, for example "10117". Must be a postcode in the marketplace country selected above. Use together with the search radius below.

## `radiusKm` (type: `integer`):

How far from the postcode to search, in kilometres. Only applies when a postcode is set. Buycycle supports 10, 25, 50, 100, 150, 200, 250, and 300 km — other values are rounded up to the nearest supported one, and 300 km is the widest available.

## `sortBy` (type: `string`):

Order the listings before they are collected. Useful with a result limit — for example, sort by lowest price to capture the cheapest bikes first. Applies to pasted URLs too, unless the URL already sets its own order.

## `includeFullSpecs` (type: `boolean`):

Fetch the complete specification for every listing. Adds condition, frame material, brake type, shifting, colour, wheel size, suspension, seller city and country, model family, buycycle's price rating, and the seller's description. Turn this off for a much faster, cheaper run that returns only the basics (title, brand, price, MSRP, year, frame size, groupset, photos) — the fields listed above will be empty.

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

Maximum number of results to return. Note: buycycle's search returns at most 10,000 results per unique filter combination, even when more items match (the full bike catalogue is ~49,000). To collect more, split your run across narrower filters — for example by brand, category, country, or price range. Set to 0 for as many as the site will return (up to that 10,000 cap). Results arrive in pages and the last page is always returned in full, so you may receive slightly more than this number.

## Actor input object example

```json
{
  "startUrls": [],
  "searchQueries": [],
  "country": "de",
  "mainTypes": [],
  "bikeTypes": [],
  "categories": [],
  "brands": [],
  "families": [],
  "frameSizes": [],
  "conditions": [],
  "frameMaterials": [],
  "brakeTypes": [],
  "shifts": [],
  "colors": [],
  "gender": "any",
  "eBike": "any",
  "frameset": "any",
  "sellerType": "any",
  "radiusKm": 50,
  "sortBy": "relevance",
  "includeFullSpecs": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped bike listings with key 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 = {
    "startUrls": [],
    "searchQueries": [],
    "country": "de",
    "mainTypes": [],
    "bikeTypes": [],
    "categories": [],
    "brands": [],
    "families": [],
    "frameSizes": [],
    "conditions": [],
    "frameMaterials": [],
    "brakeTypes": [],
    "shifts": [],
    "colors": [],
    "gender": "any",
    "eBike": "any",
    "frameset": "any",
    "sellerType": "any",
    "highDemandOnly": false,
    "postcode": "",
    "radiusKm": 50,
    "sortBy": "relevance",
    "includeFullSpecs": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/buycycle-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 = {
    "startUrls": [],
    "searchQueries": [],
    "country": "de",
    "mainTypes": [],
    "bikeTypes": [],
    "categories": [],
    "brands": [],
    "families": [],
    "frameSizes": [],
    "conditions": [],
    "frameMaterials": [],
    "brakeTypes": [],
    "shifts": [],
    "colors": [],
    "gender": "any",
    "eBike": "any",
    "frameset": "any",
    "sellerType": "any",
    "highDemandOnly": False,
    "postcode": "",
    "radiusKm": 50,
    "sortBy": "relevance",
    "includeFullSpecs": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/buycycle-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 '{
  "startUrls": [],
  "searchQueries": [],
  "country": "de",
  "mainTypes": [],
  "bikeTypes": [],
  "categories": [],
  "brands": [],
  "families": [],
  "frameSizes": [],
  "conditions": [],
  "frameMaterials": [],
  "brakeTypes": [],
  "shifts": [],
  "colors": [],
  "gender": "any",
  "eBike": "any",
  "frameset": "any",
  "sellerType": "any",
  "highDemandOnly": false,
  "postcode": "",
  "radiusKm": 50,
  "sortBy": "relevance",
  "includeFullSpecs": true,
  "maxResults": 100
}' |
apify call solidcode/buycycle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Buycycle Scraper",
        "description": "[💰 $0.09 / 1K] Extract used bike listings from buycycle.com, Europe's largest used bike marketplace — brand, model, price, MSRP, discount, frame size, year, groupset, condition, e-bike status, seller type, and photos. Search by keyword or filters, or paste a URL.",
        "version": "1.0",
        "x-build-id": "NdkM4Zz3n366uIBXW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~buycycle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-buycycle-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/solidcode~buycycle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-buycycle-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/solidcode~buycycle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-buycycle-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",
                "properties": {
                    "startUrls": {
                        "title": "Buycycle URLs",
                        "type": "array",
                        "description": "Paste one or more buycycle.com shop, search, or individual bike URLs — for example https://buycycle.com/en-de/shop/main-types/bikes or https://buycycle.com/en-de/product/canyon-aeroad-cf-slx. Leave empty to build a search with the filters below instead. A URL wins on any filter it already carries; every other setting you choose still applies on top of it.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Free-text searches, for example \"Canyon Aeroad\" or \"Specialized Tarmac\". Each keyword is collected separately. Leave empty to browse by filters only. Ignored when URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Marketplace country",
                        "enum": [
                            "de",
                            "at",
                            "be",
                            "bg",
                            "ch",
                            "cy",
                            "cz",
                            "dk",
                            "ee",
                            "es",
                            "fi",
                            "fr",
                            "gr",
                            "hr",
                            "hu",
                            "ie",
                            "it",
                            "lt",
                            "lu",
                            "lv",
                            "nl",
                            "no",
                            "pl",
                            "pt",
                            "ro",
                            "se",
                            "si",
                            "sk",
                            "us"
                        ],
                        "type": "string",
                        "description": "Which buycycle storefront to search. This sets the currency and the pool of sellers that ship to you."
                    },
                    "mainTypes": {
                        "title": "What to look for",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Buycycle sells complete bikes as well as gear for other sports. Leave empty for complete bikes only.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bikes",
                                "cycling-gear",
                                "running",
                                "winter-sports",
                                "outdoor",
                                "ball-sports",
                                "water-sports",
                                "racket-sports",
                                "other"
                            ],
                            "enumTitles": [
                                "Bikes",
                                "Cycling gear & parts",
                                "Running",
                                "Winter sports",
                                "Outdoor",
                                "Ball sports",
                                "Water sports",
                                "Racket sports",
                                "Other"
                            ]
                        }
                    },
                    "bikeTypes": {
                        "title": "Bike type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these kinds of bikes. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "road-gravel",
                                "mountainbike",
                                "urban-touring",
                                "youth"
                            ],
                            "enumTitles": [
                                "Road & gravel",
                                "Mountain bike",
                                "Urban & touring",
                                "Youth"
                            ]
                        }
                    },
                    "categories": {
                        "title": "Category",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "A finer breakdown than bike type, for example gravel, trail, or triathlon. Leave empty for all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "road",
                                "gravel",
                                "triathlon",
                                "cyclocross",
                                "mtb",
                                "trail",
                                "enduro",
                                "downhill",
                                "crosscountry",
                                "city",
                                "trekking",
                                "urban",
                                "dutch-bike",
                                "folding",
                                "cargo-transport",
                                "vintage",
                                "bmx",
                                "other-urban",
                                "other-youth",
                                "other"
                            ],
                            "enumTitles": [
                                "Road",
                                "Gravel",
                                "Triathlon",
                                "Cyclocross",
                                "Mountain bike",
                                "Trail",
                                "Enduro",
                                "Downhill",
                                "Cross country",
                                "City",
                                "Trekking",
                                "Urban",
                                "Dutch bike",
                                "Folding",
                                "Cargo & transport",
                                "Vintage",
                                "BMX",
                                "Other urban",
                                "Other youth",
                                "Other"
                            ]
                        }
                    },
                    "brands": {
                        "title": "Brands",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these brands, for example \"canyon\", \"specialized\", or \"trek\". Add one brand per entry, in lowercase with dashes instead of spaces. Leave empty for all brands.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "families": {
                        "title": "Model families",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these model lines, for example \"aeroad\" or \"tarmac\". Works best together with the matching brand. Leave empty for all models.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "frameSizes": {
                        "title": "Frame size",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include bikes in these frame sizes. Leave empty for all sizes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "xxxs",
                                "xxs",
                                "xs",
                                "s",
                                "m",
                                "l",
                                "xl",
                                "xxl",
                                "one-size-bike",
                                "youth"
                            ],
                            "enumTitles": [
                                "XXXS",
                                "XXS",
                                "XS",
                                "S",
                                "M",
                                "L",
                                "XL",
                                "XXL",
                                "One size",
                                "Youth"
                            ]
                        }
                    },
                    "conditions": {
                        "title": "Condition",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include bikes in these conditions. Leave empty for all conditions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fair",
                                "good",
                                "very-good",
                                "new",
                                "brand-new-with-guarantee"
                            ],
                            "enumTitles": [
                                "Fair",
                                "Good",
                                "Very good",
                                "New",
                                "Brand new with warranty"
                            ]
                        }
                    },
                    "frameMaterials": {
                        "title": "Frame material",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include bikes with these frame materials. Leave empty for all materials.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "carbon",
                                "aluminum",
                                "steel",
                                "titanium",
                                "magnesium"
                            ],
                            "enumTitles": [
                                "Carbon",
                                "Aluminium",
                                "Steel",
                                "Titanium",
                                "Magnesium"
                            ]
                        }
                    },
                    "brakeTypes": {
                        "title": "Brake type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include bikes with these brakes. Leave empty for all brake types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "disc",
                                "rim",
                                "drum",
                                "coaster",
                                "other"
                            ],
                            "enumTitles": [
                                "Disc brakes",
                                "Rim brakes",
                                "Drum brakes",
                                "Coaster brakes",
                                "Other"
                            ]
                        }
                    },
                    "shifts": {
                        "title": "Shifting",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include bikes with this shifting type. Electronic covers Di2, eTap, and EPS; mechanical is cable-operated.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "electronic",
                                "mechanical",
                                "other"
                            ],
                            "enumTitles": [
                                "Electronic",
                                "Mechanical",
                                "Other"
                            ]
                        }
                    },
                    "colors": {
                        "title": "Colour",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include bikes in these colours. Leave empty for all colours.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "000000",
                                "FFFFFF",
                                "D1D5DB",
                                "3B82F6",
                                "EF4444",
                                "80BE70",
                                "F59E0B",
                                "9A2DF0"
                            ],
                            "enumTitles": [
                                "Black",
                                "White",
                                "Light grey",
                                "Blue",
                                "Red",
                                "Green",
                                "Orange",
                                "Purple"
                            ]
                        }
                    },
                    "gender": {
                        "title": "Intended rider",
                        "enum": [
                            "any",
                            "unisex",
                            "men",
                            "women",
                            "kids"
                        ],
                        "type": "string",
                        "description": "Only include items made for this rider category. Note: buycycle applies this to gear and apparel only — combining it with \"Bikes\" returns no results."
                    },
                    "eBike": {
                        "title": "E-bike",
                        "enum": [
                            "any",
                            "ebike",
                            "non-ebike"
                        ],
                        "type": "string",
                        "description": "Limit results to electric bikes, or exclude them entirely."
                    },
                    "frameset": {
                        "title": "Complete bike or frameset",
                        "enum": [
                            "any",
                            "complete",
                            "frameset"
                        ],
                        "type": "string",
                        "description": "Limit results to complete bikes, or to framesets sold without components."
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "any",
                            "private",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Limit results to private individuals or to professional shops and dealers."
                    },
                    "highDemandOnly": {
                        "title": "High demand only",
                        "type": "boolean",
                        "description": "Only return listings carrying buycycle's \"High demand\" badge."
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Lowest price to include, in the marketplace currency. This is the item price, before the buyer protection fee is added."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Highest price to include, in the marketplace currency. This is the item price, before the buyer protection fee is added."
                    },
                    "minYear": {
                        "title": "Earliest model year",
                        "minimum": 2013,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Only include bikes from this model year or newer."
                    },
                    "maxYear": {
                        "title": "Latest model year",
                        "minimum": 2013,
                        "maximum": 2027,
                        "type": "integer",
                        "description": "Only include bikes from this model year or older."
                    },
                    "postcode": {
                        "title": "Postcode",
                        "type": "string",
                        "description": "Find bikes near a postcode, for example \"10117\". Must be a postcode in the marketplace country selected above. Use together with the search radius below."
                    },
                    "radiusKm": {
                        "title": "Search radius (km)",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "How far from the postcode to search, in kilometres. Only applies when a postcode is set. Buycycle supports 10, 25, 50, 100, 150, 200, 250, and 300 km — other values are rounded up to the nearest supported one, and 300 km is the widest available."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "new",
                            "lowest-price",
                            "highest-price"
                        ],
                        "type": "string",
                        "description": "Order the listings before they are collected. Useful with a result limit — for example, sort by lowest price to capture the cheapest bikes first. Applies to pasted URLs too, unless the URL already sets its own order."
                    },
                    "includeFullSpecs": {
                        "title": "Include full specifications",
                        "type": "boolean",
                        "description": "Fetch the complete specification for every listing. Adds condition, frame material, brake type, shifting, colour, wheel size, suspension, seller city and country, model family, buycycle's price rating, and the seller's description. Turn this off for a much faster, cheaper run that returns only the basics (title, brand, price, MSRP, year, frame size, groupset, photos) — the fields listed above will be empty."
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of results to return. Note: buycycle's search returns at most 10,000 results per unique filter combination, even when more items match (the full bike catalogue is ~49,000). To collect more, split your run across narrower filters — for example by brand, category, country, or price range. Set to 0 for as many as the site will return (up to that 10,000 cap). Results arrive in pages and the last page is always returned in full, so you may receive slightly more than this number."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
