# BikeDekho Scraper: Used Bikes, New Bikes & Dealers (`recordsdata/bikedekho-scraper`) Actor

Scrape bikedekho.com, India's motorcycle and scooter marketplace: used bike listings with price, km driven, owners, city and photos, new bike specs and ex-showroom prices, on-road prices by city and dealer showrooms. No login, no proxy. Export JSON, CSV or Excel.

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

## Pricing

from $22.00 / 1,000 used bike ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

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

## 🏍️ BikeDekho Scraper: Used Bikes, New Bikes, On-Road Prices & Dealers

> 🚀 **Export India's motorcycle and scooter data from bikedekho.com in minutes.** 5,826 used ads, 951 new bike models and 15,000 dealer pages, with price, year, kilometres, owners, city, specifications and photos. No login, no proxy, no browser.

**Quick answer:** to scrape used bikes from BikeDekho, open the Actor, choose *Used bikes and scooters (ads)*, add a city such as Delhi or a brand such as Royal Enfield, set the number of results and click Start. Brand, model, body type, fuel, engine size, price, year and kilometre filters are applied by the site itself.

BikeDekho Scraper reads the public pages of bikedekho.com, a marketplace run by Girnar Software, the company behind CarDekho. It returns clean, typed rows for four kinds of data: second-hand bike and scooter ads, new bike models with full specifications, on-road prices per variant and city, and authorised dealer showrooms. You can export the result as JSON, CSV, Excel, XML or HTML, or read it through the Apify API.

| 🎯 Target audience | 💡 Primary use cases |
|---|---|
| Used-bike dealers and marketplaces | Price benchmarking by model, year and city |
| Lenders, insurers and valuation teams | Residual-value curves and loan sizing |
| Market researchers and analysts | Spec and price comparison of new models, EV tracking |
| Automotive data teams | Feeding catalogues, dashboards and pricing models |

### 📋 What does BikeDekho Scraper do?

- **Used bikes and scooters**: the national catalogue (5,826 ads on 2026-10-19) or any city. Each row has the asking price in rupees, registration year, kilometres, owner count, fuel, make, model, variant, photos and the exact time the ad was posted.
- **Ad details** (optional): transmission, engine size, power, torque, fuel economy, kerb weight, brakes, tyres, ABS, registration state and RTO code, view count, last update, seller type and the new-bike price for comparison.
- **New bikes**: one row per model page with launch date, 25+ specification fields, ex-showroom price range, on-road price range, variants, colours, user rating and the on-road prices of the top cities. Electric models add battery, motor power, range and charging time.
- **On-road prices**: one row per variant and city with ex-showroom price, RTO charges, insurance, other charges, on-road price and the monthly EMI the site shows.
- **Dealers**: authorised showrooms by brand and city with address, locality, pincode and coordinates. Phone and WhatsApp numbers only when you switch them on.
- **Monitoring**: schedule the Actor and receive only ads you have not collected before, plus a price-change row when a known ad changes price.

> 💡 **Why it matters:** BikeDekho shows prices, kilometres and owner counts, but only one search at a time and without an export. This Actor turns the same public pages into a table you can filter, join and keep.

A minimal example input:

```json
{
  "mode": "used-bikes",
  "cities": ["Bangalore"],
  "brands": ["Royal Enfield"],
  "priceTo": 150000,
  "yearFrom": 2018,
  "scrapeDetails": true,
  "maxItems": 100
}
```

#### Five ways to collect data

| Mode (`mode`) | Use it to | Record types |
|---|---|---|
| `used-bikes` | Search second-hand ads by city, brand, model, body type, fuel, engine size, price, year and kilometres | `used-bike`, `price-change` |
| `new-bikes` | Read new models with specs, ex-showroom and on-road prices | `new-bike` |
| `on-road-prices` | Price every variant of chosen models in chosen cities | `on-road-price` |
| `dealers` | List showrooms by brand and city | `dealer` |
| `urls` | Refresh known ads by number or address, replay a search address, read a model, price or showroom page | any of the above |

City, brand and model names are looked up on the site at run time and are not case sensitive. The site accepts one engine size range per search, so each range you tick is searched separately.

### 📊 Output: what data do you get?

Every row has a `recordType`. Fields that do not apply to a record type are left out, never filled with `null`.

| Field | Description |
|---|---|
| `recordType` | `used-bike`, `new-bike`, `on-road-price`, `price-change` or `dealer` |
| `listingId`, `dealerId` | Ad number (24 characters), model or price id, dealer number |
| `title`, `url`, `imageUrl` | Title, address on bikedekho.com and cover photo |
| `make`, `model`, `variant`, `year` | Brand, model, variant and registration or launch year |
| `vehicleType`, `bodyType`, `fuelType`, `transmission` | `motorcycle` or `scooter`, body type, fuel, gearbox (ad details) |
| `engineCc`, `power`, `powerPs`, `torque`, `torqueNm` | Engine size, power and torque as text and as numbers |
| `fuelEfficiencyKmpl`, `kerbWeightKg`, `fuelTankLitres`, `topSpeedKmph` | Efficiency, weight, tank and top speed |
| `launchedAt`, `modelStatus`, `cylinders`, `coolingType`, `gearbox`, `emissionNorm` | New-bike rows: launch date, model status, engine layout, cooling, gears and emission norm |
| `seatHeightMm`, `groundClearanceMm`, `frontSuspension`, `rearSuspension`, `tyreType`, `userReportedMileageKmpl` | More specification fields, and the mileage owners report on the site |
| `batteryCapacity`, `motorPower`, `claimedRange`, `chargingTime` | Electric models only |
| `brakeType`, `frontBrake`, `rearBrake`, `frontTyre`, `rearTyre`, `abs` | Brakes, tyres and ABS |
| `mileage`, `mileageUnit`, `ownerCount` | Kilometres driven and number of owners |
| `price`, `priceType`, `currency`, `priceOnRequest` | Price in INR, its type (`asking`, `ex-showroom` or `on-road`) and `true` when no price is shown |
| `newBikePrice` | The site's new-bike price for the same variant (ad details) |
| `exShowroomPrice`, `rtoCharges`, `insurance`, `otherCharges`, `onRoadPrice`, `emiPerMonth`, `priceCity` | On-road price breakdown per variant, and the city it applies to |
| `exShowroomPriceMax`, `onRoadPriceMin`, `onRoadPriceMax`, `variantCount`, `ratingCount` | New-bike rows: top of the price range, on-road range, number of variants and of ratings |
| `previousPrice`, `priceChange`, `priceChangePct`, `changeType` | Price-change rows: old price, difference, percent, `price-drop` or `price-increase` |
| `city`, `registrationState`, `rtoCode` | City of the ad, state and RTO office code of the plate |
| `listedAt`, `updatedOn`, `viewCount` | Posting time (exact), last update day and views |
| `images`, `imageCount`, `stockImageUrl` | Seller photos, their count, and the catalogue photo when the seller added none |
| `sellerType`, `isPrivateSeller` | `individual` or dealer type, and the private flag (ad details) |
| `variants`, `colorCount`, `rating`, `reviewCount`, `cityOnRoadPrices`, `specifications`, `description` | New-bike rows: variants with prices, colours, rating, city prices, all specification groups and the model summary |
| `address`, `locality`, `pincode`, `latitude`, `longitude`, `dealerPhone`, `dealerWhatsapp` | Dealer rows (phone and WhatsApp only with contact details on) |
| `sourceSite`, `country`, `state`, `brandSlug`, `modelSlug`, `variantSlug`, `isFeatured` | Source, country code, state (dealers), the site's own address names, and the featured-ad flag |
| `error` | Only on the single free row a run writes when the input is invalid or an ad is gone, with the reason |
| `scrapedAt` | When the row was collected |

#### Sample output

A real `used-bike` row with ad details, collected on 2026-10-19:

```json
{
  "imageUrl": "https://cdn.bikedekho.com/upload/usedbikesimages/2026/09/6aabccb2a50d8.jpg",
  "recordType": "used-bike",
  "title": "2023 TVS Raider Split Seat",
  "listingId": "6aabcca14f7245733b0b75e1",
  "url": "https://www.bikedekho.com/used-bike-details/used-tvs-raider-raider-disc-bikes-bangalore_6aabcca14f7245733b0b75e1.htm",
  "sourceSite": "bikedekho.com",
  "country": "IN",
  "city": "Bangalore",
  "registrationState": "Karnataka",
  "rtoCode": "KA01",
  "make": "TVS",
  "model": "Raider",
  "variant": "Split Seat",
  "vehicleType": "motorcycle",
  "bodyType": "Commuter",
  "year": 2023,
  "fuelType": "Petrol",
  "transmission": "Manual",
  "engineCc": 124.8,
  "power": "11.38 PS",
  "powerPs": 11.38,
  "torque": "11.75 Nm",
  "torqueNm": 11.75,
  "fuelEfficiencyKmpl": 71.94,
  "kerbWeightKg": 123,
  "brakeType": "Disc",
  "mileage": 12900,
  "mileageUnit": "km",
  "ownerCount": 1,
  "price": 75000,
  "priceType": "asking",
  "currency": "INR",
  "newBikePrice": 94620,
  "listedAt": "2026-09-17T11:18:57.000Z",
  "updatedOn": "2026-09-22",
  "viewCount": 486,
  "images": [
    "https://cdn.bikedekho.com/upload/usedbikesimages/2026/09/6aabccb2a50d8.jpg",
    "https://cdn.bikedekho.com/upload/usedbikesimages/2026/09/6aabccb2c8e02.jpg",
    "https://cdn.bikedekho.com/upload/usedbikesimages/2026/09/6aabccb2d0830.jpg"
  ],
  "imageCount": 3,
  "sellerType": "individual",
  "isPrivateSeller": true,
  "scrapedAt": "2026-10-19T07:01:18.599Z"
}
```

A real `on-road-price` row:

```json
{
  "recordType": "on-road-price",
  "title": "Honda SP 125 STD on-road price in Bangalore",
  "listingId": "4477-bangalore",
  "url": "https://www.bikedekho.com/honda/sp125/price-in-bangalore",
  "city": "Bangalore",
  "make": "Honda",
  "model": "SP 125",
  "variant": "STD",
  "fuelType": "Petrol",
  "engineCc": 123.94,
  "price": 113390,
  "priceType": "on-road",
  "currency": "INR",
  "exShowroomPrice": 91774,
  "rtoCharges": 13723,
  "insurance": 6498,
  "otherCharges": 1395,
  "onRoadPrice": 113390,
  "emiPerMonth": 3289
}
```

### ✨ Why choose this Actor

- **Filters the site applies for you**: 30 brands, 333 models, 17 body types, petrol or electric, 8 engine size ranges, price, year and kilometre ranges. Models are matched by name, so `Activa` picks every Activa generation.
- **No depth cap**: all 292 result pages of the national search answer, so a full read is possible. One search returns about 20 ads per second; with ad details switched on, about 1 ad per second. Searches for several cities run side by side.
- **Clean, typed output**: numbers are numbers, dates are ISO 8601 and the column order is the same for every row.
- **Honest errors**: an unknown city or brand ends the run with one free error row that explains the problem and lists valid brand names or example cities. The site would silently answer with the whole country or with Delhi, and the Actor never passes that on as a match.
- **Privacy built in**: seller names, phone numbers and full registration plates are never output. Only the RTO office code and its state are kept.
- **Cheap to run**: plain HTTP requests and 256 MB of memory. A 3-result run uses about 0.0001 USD of platform compute.

### 📈 How it compares to alternatives

When this Actor was built (2026-10-19) no other Actor on the Apify Store targeted bikedekho.com. The closest options cover other sites:

| | BikeDekho Scraper | BikeWale scrapers | Quikr and OLX India scrapers |
|---|---|---|---|
| Site | bikedekho.com | bikewale.com | quikr.com and olx.in classifieds |
| Used bike ads with kilometres, owners and posting time | Yes | Not offered (new bikes, prices, specs) | Yes, mixed with cars and other goods |
| New models with specs and ex-showroom price | Yes | Yes | No |
| On-road price breakdown per variant and city | Yes | Yes, in one of them | No |
| Dealer showrooms with address and coordinates | Yes | Not listed | No |
| Monitor mode with price-change rows | Yes | Not listed | Not listed |

Comparison based on the Store listings read on 2026-10-19. Use a BikeWale scraper next to this one if you want to compare the two portals' new-bike prices.

### 🚀 How to scrape BikeDekho in four steps

1. Create a free Apify account at [console.apify.com](https://console.apify.com) and open this Actor.
2. Choose **What to collect**: used bikes, new bikes, on-road prices, dealers or addresses.
3. Add cities, brands or models, and any filters such as price, year or engine size. Set **Maximum items**.
4. Click **Start**, then download the dataset from the **Storage** tab as JSON, CSV, Excel or XML, or read it through the API.

### ⚠️ Good to know before you buy data

- **Most used ads on the site are old.** Of the 5,826 ads read on 2026-10-19, 5,628 were posted in 2019 or 2020 and only 11 in the last twelve months. The site keeps expired ads online, so use **Listed within the last days** or the posting time `listedAt` to keep fresh ones. That filter still reads the result pages in order, because the site has no sort option.
- **Prices are what sellers typed.** A few ads show a price of a few rupees or a typo; the Actor reports the site's number and leaves the judgement to you.
- **List rows have no city when you search all of India.** The site names the city only inside a city search or on the ad page, so add a city or switch on **Open each used-bike ad** when you need it.
- **Price history is not published** by the site, so the Actor offers monitoring instead: run it on a schedule with **Only new rows** and **Report price changes**.
- **Engine, transmission and registration data live on the ad page.** Switching on ad details costs one more page read per ad.

### 💼 Business use cases

**Used-bike dealers and marketplaces.** Track asking prices by model, year and city, spot undervalued ads by comparing `price` with `newBikePrice`, and feed a pricing model with thousands of rows.

**Finance, insurance and valuation teams.** Build residual-value curves from year, kilometres and owner count, and compare the real on-road price with the ex-showroom price for loan sizing.

**Market and product research.** Compare specifications, mileage claims, ratings and prices of new models in one table, or follow electric two-wheeler range and battery specs over time.

**Network planning.** Map authorised showrooms by brand, city, pincode and coordinates to plan service coverage or sales territories.

### 🔌 Automating BikeDekho Scraper

Schedule a daily run with **Only new rows** to receive each new ad once, and send the dataset to Google Sheets, Slack, Make, Zapier, Airbyte or your own database through Apify integrations and webhooks. Name each saved search with **Monitor name** so that several schedules do not share one memory.

### 🌟 Beyond business use cases

- **Research**: study how two-wheeler prices fall with age and kilometres across Indian cities.
- **Personal**: shortlist a second-hand scooter by city, budget and owner count, and compare it with the new price.
- **Education**: build a dataset for a regression or data-visualisation course.
- **Journalism**: follow the spread of electric two-wheelers and their prices.

### 🤖 Ask an AI assistant about this scraper

Paste the dataset link or a few rows into your assistant and ask, for example: "Which Royal Enfield models in Bangalore are priced more than 30 percent below their new-bike price?", "What is the median asking price of a 2019 Activa by city?", or "List the cheapest electric scooters with a claimed range above 100 km." Each question maps to fields in the table above.

### Frequently Asked Questions

**How do I scrape used bikes from BikeDekho?**
Pick *Used bikes and scooters (ads)*, add a city or a brand and click Start. Add price, year, kilometre, engine size, body type or fuel filters to narrow the result.

**Can I get every used bike on the site?**
Yes. Leave cities and brands empty to read all 292 result pages of the national search (5,826 ads on 2026-10-19). A listing-only run of the whole country takes about five minutes.

**Which cities can I use?**
Any city that has ads on bikedekho.com, written as on the site, for example Delhi, Mumbai, Bangalore, Pune, Hyderabad or Navi Mumbai. An unknown city returns one error row instead of another place.

**Why do some rows have no city, engine or transmission?**
The list of ads carries a shorter record than the ad page. Switch on **Open each used-bike ad** for the full record.

**Does it return seller phone numbers?**
No. Seller names, phone numbers and full registration plates are never output. Dealer showroom phone and WhatsApp numbers are returned only when you tick **Include dealer contact details**.

**What is the difference between ex-showroom and on-road price?**
Ex-showroom is the vehicle price before taxes and fees. On-road adds RTO charges, insurance and other charges. The on-road mode returns each part for every variant in the cities you choose.

**How fresh is the data?**
Every run reads the live pages of bikedekho.com. The posting time of each ad comes from its own number, so `listedAt` is exact. The site itself keeps many old ads online.

**Can I track price changes?**
Yes. Turn on **Only new rows** and **Report price changes** and schedule the Actor. A known ad with a new price comes back as a `price-change` row with the previous price and the change in percent.

**Do I need a proxy or a login?**
No. The site answers plain requests, so the Actor uses none. A proxy field exists only for networks that require one.

**Can I filter by engine size and brand together?**
Yes. Each engine size range you tick is searched on its own, because the site accepts one range per search, and the results are merged.

**What formats can I export?**
JSON, CSV, Excel, XML and HTML, from the Storage tab or through the API.

**Is it legal to scrape BikeDekho?**
The Actor reads public pages at a polite pace of about four requests per second and skips the parts the site's robots.txt disallows. The site's terms of use describe its content as meant for personal, non-commercial use, so check them and local law before commercial reuse.

### 🔌 Integrate with any app

Call the Actor from any language through the Apify API. Replace the token and read the default dataset when the run ends:

```bash
curl -X POST "https://api.apify.com/v2/acts/RecordsData~bikedekho-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode":"used-bikes","cities":["Delhi"],"maxItems":50}'
```

The same input works in the Apify client for JavaScript and Python, in Make, Zapier, n8n and in the Apify MCP server for AI agents.

### 🔗 Recommended Actors

> 💡 **Pro Tip:** browse the complete [RecordsData collection](https://apify.com/RecordsData) for more data scrapers.

- [Auteco Scraper](https://apify.com/RecordsData/auteco-co-scraper): Colombian motorcycles, parts and dealers, to compare Latin American and Indian two-wheeler catalogues.
- [NHTSA Recalls Scraper](https://apify.com/RecordsData/nhtsa-vehicle-safety-aggregator): US vehicle recalls, VIN decoding and safety ratings, to add safety context to vehicle datasets.

**🆘 Need Help?** Open the Issues tab or write to contact.punkrecordsdata@gmail.com.

> **⚠️ Disclaimer:** this is an independent tool and is not affiliated with BikeDekho or Girnar Software. It collects only publicly available data.

# Actor input Schema

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

used-bikes = second-hand motorcycle and scooter ads for the filters below. new-bikes = one row per new model with specs, ex-showroom price and ratings. on-road-prices = one row per variant and city with RTO, insurance and on-road price. dealers = authorised showrooms by brand and city. urls = addresses and ad numbers you list.

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

Stops after this many rows (all record types together). Free plans are limited to 10 items per run.

## `cities` (type: `array`):

City names as written on the site, for example Delhi, Mumbai, Bangalore, Pune or Navi Mumbai. used-bikes: each city is a separate search, empty means all of India. on-road-prices: the cities to price (empty means Delhi). dealers: the cities to list (empty means every city that has showrooms). An unknown city is reported, it never silently returns another place.

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

Brand names as written on the site, for example Royal Enfield, Honda, TVS, Bajaj, Yamaha or Hero. Case does not matter. The brand list is read from the site at run time and an unknown brand is reported with the available ones. Empty means every brand.

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

Model names or parts of them, for example Activa, Classic 350, Pulsar or SP125. A name picks every model that contains all its words. Used bikes, new bikes and on-road prices read it; with brands it narrows inside them.

## `bodyTypes` (type: `array`):

Only used bikes of these types (any of them). Empty means all types.

## `fuelType` (type: `string`):

Only used bikes with this fuel. The site lists petrol and electric bikes.

## `engineSizes` (type: `array`):

Only used bikes in these engine size ranges. The site accepts one range per search, so each range you pick is searched separately. Empty means all sizes.

## `priceFrom` (type: `integer`):

Only used bikes priced at or above this amount in rupees. 0 or empty means no limit.

## `priceTo` (type: `integer`):

Only used bikes priced at or below this amount in rupees. 0 or empty means no limit.

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

Only bikes of this registration year or newer. 0 or empty means no limit.

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

Only bikes of this registration year or older. 0 or empty means no limit.

## `mileageFrom` (type: `integer`):

Only bikes with at least this odometer reading in km. 0 or empty means no limit.

## `mileageTo` (type: `integer`):

Only bikes with at most this odometer reading in km. 0 or empty means no limit.

## `listedWithinDays` (type: `integer`):

Only ads posted in the last N days (the posting time is read from the ad number). 0 or empty means no limit. The site has no sort order, so the search still reads its result pages in order and keeps the recent ones.

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

urls mode. bikedekho.com addresses: a used-bike search (https://www.bikedekho.com/used-bikes+in+pune), one ad page, a model page (/honda/sp125), a price page (/honda/sp125/price-in-delhi), a brand page (/honda-bikes) or a showroom page (/showrooms/honda/delhi). Ad numbers can go in the next field.

## `listingIds` (type: `array`):

urls mode. The 24 letters and digits at the end of an ad address, for example 68983ad96f92ad806d0f17e2. Each one returns the full ad.

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

On: open every ad page to add transmission, engine, power, brakes, tyres, ABS, registration state, views, last update and seller type (vehicle-detail-record). Off: the data of the search result only, much faster (vehicle-record).

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

Adds the business phone and WhatsApp number of dealer showrooms (dealers mode). Seller names, phone numbers and full registration plates of used-bike ads are never output.

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

Skips every row delivered in an earlier run with the same monitor name, so scheduled runs return only what is new and you pay only for those.

## `trackPriceChanges` (type: `boolean`):

Needs Only new rows. A used bike, model or on-road price seen before with a different price comes back as a price-change row with the previous price and the change in percent.

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

Name of the memory used by Only new rows. Use one name per saved search. Empty derives a name from your filters.

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

Clears the memory of the monitor name before this run.

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

How many pages are read at the same time (1 to 5). Requests are paced at about four per second in total, so a higher value adds little.

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

Optional. Empty means direct requests, which work. Add a proxy only if your own network needs one.

## Actor input object example

```json
{
  "mode": "used-bikes",
  "maxItems": 10,
  "cities": [
    "Delhi"
  ],
  "brands": [],
  "models": [],
  "bodyTypes": [],
  "fuelType": "any",
  "engineSizes": [],
  "startUrls": [],
  "listingIds": [],
  "scrapeDetails": false,
  "includeContactDetails": false,
  "onlyNew": false,
  "trackPriceChanges": false,
  "stateKey": "",
  "resetSeen": false,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Key fields per row

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

Complete dataset with all fields

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "cities": [
        "Delhi"
    ],
    "brands": [],
    "models": [],
    "priceFrom": 0,
    "priceTo": 0,
    "yearFrom": 0,
    "yearTo": 0,
    "mileageFrom": 0,
    "mileageTo": 0,
    "listedWithinDays": 0,
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/bikedekho-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "cities": ["Delhi"],
    "brands": [],
    "models": [],
    "priceFrom": 0,
    "priceTo": 0,
    "yearFrom": 0,
    "yearTo": 0,
    "mileageFrom": 0,
    "mileageTo": 0,
    "listedWithinDays": 0,
    "startUrls": [],
    "listingIds": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "cities": [
    "Delhi"
  ],
  "brands": [],
  "models": [],
  "priceFrom": 0,
  "priceTo": 0,
  "yearFrom": 0,
  "yearTo": 0,
  "mileageFrom": 0,
  "mileageTo": 0,
  "listedWithinDays": 0,
  "startUrls": [],
  "listingIds": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/bikedekho-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FBzsT1avLqZYV2Ptd/builds/GcZnCAiAfU07oKuqp/openapi.json