# 91Wheels Scraper: Bikes, Scooters, Prices & Dealers (`recordsdata/91wheels-scraper`) Actor

Scrape 91wheels.com, India's motorcycle and scooter portal: 530 models with specs, 947 variant spec sheets, on-road prices for 1,053 cities, 19,000+ dealer showrooms and upcoming launches, plus monitoring of new models and price changes. No login, no proxy. Export JSON, CSV or Excel.

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

## Pricing

from $22.00 / 1,000 bike or scooter models

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)

## 91Wheels Scraper: Bikes, Scooters, Prices and Dealers in India

> 91Wheels Scraper is an Apify Actor that extracts motorcycle and scooter data from 91wheels.com, an Indian vehicle portal: 530 models (432 on sale), ex-showroom and on-road prices for 1,053 cities, variant spec sheets and dealer showrooms. It needs no login and no proxy, and exports JSON, CSV or Excel.

Export the result as JSON, CSV, Excel, XML or HTML, or read it through the Apify API. Every figure on this page was measured on 2026-10-19.

### What can you scrape from 91Wheels?

- **Bike and scooter models**: one row per model with brand, body type, fuel, engine size, power and torque as text and as numbers, efficiency, top speed, weight, dimensions, the ex-showroom price range, rating, review count, key features, brochure link and photos. 530 models: 381 motorcycles and 149 scooters, 432 on sale and 98 upcoming with an expected launch date.
- **Variants**: one row per variant with the full specification sheet (up to 70 fields: brakes, suspension, frame, wheels, lighting, console, connectivity, battery and range for electric models) and the ex-showroom price. 947 variants were on sale on 2026-10-19.
- **On-road prices**: one row per variant and city with ex-showroom price, RTO charges, insurance, TCS where the site lists it (premium bikes), and the total on-road price. 1,053 cities are priced.
- **Dealers**: authorised showrooms by brand and city with address, pincode and coordinates. More than 19,000 showrooms across 46 brands, 9,570 of them for TVS alone. The phone number of a showroom comes only when you switch it on.
- **Monitoring**: a scheduled run returns only rows you have not collected before, plus a price-change row when a known price moved.

### Why use this actor?

- **Filters the site applies for you**: brand, model name, motorcycle or scooter, body type, fuel, ex-showroom price range and on-sale or upcoming status.
- **No depth cap**: the whole catalogue is reachable, 530 models, 947 variants and 9,570 TVS showrooms were each read in one pass.
- **Typed output**: prices, engine sizes and weights are numbers, dates are ISO 8601, power comes with a number in PS next to the original text, and the column order is stable.
- **Cleaned source data**: units are converted (kW, bhp and HP to PS), impossible values such as a 3 kg motorcycle are dropped instead of repeated, and `&` used by the site in place of a comma is repaired.
- **Honest errors**: an unknown brand, model or city ends with one free error row that says what was not found (brands come with the closest names). It never returns another place.
- **Light on memory**: runs in 256 MB and works without a browser or a proxy.

### How to scrape 91Wheels in four steps

1. Create a free account at [console.apify.com](https://console.apify.com) and open the actor.
2. Choose **What to collect**: models, variants, on-road prices, dealers or addresses.
3. Add brands, models or cities and any filter such as body type, fuel or price, then set **Maximum items**.
4. Click **Start**, then download the dataset from the **Storage** tab.

A minimal input that returns every Royal Enfield and Hero cruiser or commuter under 2 lakh rupees:

```json
{
  "mode": "models",
  "makes": ["Royal Enfield", "Hero"],
  "bodyTypes": ["cruiser", "commuter"],
  "priceTo": 200000,
  "maxItems": 100
}
```

On-road prices of one model in three cities:

```json
{
  "mode": "on-road-prices",
  "makes": ["Honda"],
  "models": ["Activa"],
  "cities": ["Mumbai", "Pune", "Bangalore"],
  "maxItems": 200
}
```

### Input

The form has 19 fields; the main ones are:

| Field | Type | Default | Meaning |
|---|---|---|---|
| `mode` | string | `models` | `models`, `variants`, `on-road-prices`, `dealers` or `urls` |
| `maxItems` | integer | 50 | Maximum rows (free plans: 10) |
| `makes` / `models` | array | empty | Brand and model names as on the site, not case sensitive; empty means all |
| `vehicleTypes` | select | both | Motorcycles, scooters or both |
| `cities` | array | empty | Cities to price (on-road prices) or to list (dealers) |
| `bodyTypes` / `fuelType` | select | any | 10 body types (motorcycles only); petrol, electric or CNG |
| `priceFrom` / `priceTo` | integer | 0 | Ex-showroom price range in INR (0 means no limit) |
| `modelStatus` | select | available | On sale, upcoming or both |
| `includeModelDetails` | boolean | true | One extra page per model for top speed, weight, warranty, counts, key features and brochure |
| `includeContactDetails` | boolean | false | Showroom phone numbers (dealers mode) |
| `startUrls` | array | empty | 91wheels.com addresses (urls mode) |
| `onlyNew` / `trackPriceChanges` / `stateKey` / `resetSeen` | mixed | off | Monitor mode and its memory |
| `proxyConfiguration` | object | none | Only for networks that need a proxy |

Names are matched the way the site writes them: `Royal Enfield` and `royalenfield` find the same brand, and `Activa` finds every Activa model. A name the site does not know gets a free error row that says what was not found. In urls mode you can paste brand pages, model pages, variant pages, price pages such as `/bikes/royalenfield/classic-350/price-in-pune` and dealer pages.

### 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`. The dataset schema has 109 fields.

| Field | Description |
|---|---|
| `recordType` | `model`, `variant`, `on-road-price`, `price-change` or `dealer` |
| `listingId`, `variantId`, `modelId` | Numbers used by the site |
| `title`, `url`, `imageUrl` | Title, address on 91wheels.com and cover photo |
| `make`, `model`, `variant` and their slugs | Brand, model and variant |
| `listingType`, `condition`, `modelStatus` | `sale`, `new`, and `available` or `upcoming` (models) |
| `vehicleType`, `bodyType`, `fuelType`, `transmission`, `driveType` | `motorcycle` or `scooter`, body type, fuel, gearbox and final drive |
| `engineSize`, `engineType`, `cylinders`, `coolingType`, `gears` | Engine block (cc) |
| `power`, `powerPs`, `torque`, `torqueNm` | Power and torque as published and as numbers |
| `fuelEfficiencyKmpl`, `topSpeedKmph`, `kerbWeightKg`, `fuelTankLitres` | Efficiency, speed, weight and tank |
| `seatHeightMm`, `groundClearanceMm`, `wheelbaseMm`, `lengthMm`, `widthMm`, `heightMm` | Dimensions |
| `brakingSystem`, `frontBrake`, `rearBrake`, `frontSuspension`, `rearSuspension`, `frameType`, `wheelType` | Chassis (variants) |
| `ledHeadlight`, `speedometer`, `console`, `usbPort`, `navigation`, `touchscreen` | Features (variants) |
| `batteryCapacityKwh`, `batteryType`, `rangeKm`, `chargingTime`, `motorPowerKw` | Electric models and variants |
| `price`, `priceMax`, `priceType`, `currency` | Price in INR and its type (`ex-showroom` or `on-road`) |
| `exShowroomPrice`, `rtoCharges`, `insurance`, `tcs`, `onRoadPrice` | On-road breakdown per variant and city |
| `previousPrice`, `priceChange`, `priceChangePct`, `changeType` | Price-change rows |
| `city`, `citySlug`, `region`, `priceCity` | City asked for, its region (state), and the city the site actually priced |
| `address`, `pincode`, `latitude`, `longitude`, `sellerPhone` | Dealer rows (phone only with contact details on) |
| `launchedAt`, `expectedLaunch`, `variantCount`, `colorCount`, `imageCount` | Dates and counts |
| `rating`, `ratingCount`, `reviewCount` | Model rating |
| `description`, `features`, `colors`, `otherSpecifications`, `brochureUrl`, `images` | Text, lists and links |
| `sourceSite`, `country`, `scrapedAt`, `error` | Source, `IN`, time of the read; `error` only on a free error row |

#### Sample output

A model row collected on 2026-10-19 (the long description and the photo list are left out here):

```json
{
  "imageUrl": "https://images.91wheels.com/assets/b_images/gallery/royalenfield/classic-350/royalenfield-classic-350-0-1768628135.png",
  "recordType": "model",
  "title": "Royal Enfield Classic 350",
  "listingId": "9899",
  "url": "https://www.91wheels.com/bikes/royalenfield/classic-350",
  "sourceSite": "91wheels.com",
  "country": "IN",
  "listingType": "sale",
  "condition": "new",
  "modelStatus": "available",
  "vehicleType": "motorcycle",
  "make": "Royal Enfield",
  "makeSlug": "royalenfield",
  "model": "Classic 350",
  "modelSlug": "classic-350",
  "bodyType": "Cruiser",
  "fuelType": "Petrol",
  "transmission": "Manual",
  "priceCity": "New Delhi",
  "engineSize": 350,
  "power": "20.48 PS @ 6100 rpm",
  "powerPs": 20.48,
  "torque": "27 Nm @ 4000 rpm",
  "torqueNm": 27,
  "fuelEfficiencyKmpl": 35,
  "fuelEfficiencyKmplMin": 35,
  "fuelEfficiencyKmplMax": 35,
  "topSpeedKmph": 115,
  "kerbWeightKg": 195,
  "seatHeightMm": 805,
  "groundClearanceMm": 170,
  "wheelbaseMm": 1390,
  "fuelTankLitres": 13,
  "warranty": "3 Years/30000 Kms",
  "price": 188934,
  "priceMax": 226069,
  "currency": "INR",
  "priceType": "ex-showroom",
  "launchedAt": "2021-09-01",
  "baseVariant": "Redditch Series Single Channel",
  "topVariant": "Chrome Series Dual Channel",
  "variantCount": 7,
  "colorCount": 7,
  "imageCount": 46,
  "rating": 4.2,
  "ratingCount": 2930,
  "reviewCount": 1209,
  "features": [
    "LED Headlamps",
    "Turn-by-Turn Navigation",
    "USB-C Charging",
    "Dual-Channel ABS",
    "Semi-Digital Cluster"
  ],
  "brochureUrl": "https://91w.s3.ap-south-1.amazonaws.com/production/assets/brochures/Classic350_brochure.pdf",
  "scrapedAt": "2026-10-19T09:17:07.531Z"
}
```

A dealer row (the phone number is added only with **Include dealer phone numbers**):

```json
{
  "imageUrl": "https://91w.s3.ap-south-1.amazonaws.com/production/images/brand-logos/bikes/heromotocorp.jpg",
  "recordType": "dealer",
  "title": "Fortpoint Hero - Byculla, Byculla West",
  "listingId": "8232",
  "url": "https://www.91wheels.com/bike-dealers/heromotocorp/mumbai",
  "sourceSite": "91wheels.com",
  "country": "IN",
  "make": "Hero",
  "makeSlug": "heromotocorp",
  "city": "Mumbai",
  "citySlug": "mumbai",
  "region": "Maharashtra",
  "address": "1B/565, Jetha Compound, Opp. Byculla Railway Station, Dr. B.A. Road, Mumbai - 400012",
  "pincode": "400012",
  "latitude": 18.985533,
  "longitude": 72.835737,
  "scrapedAt": "2026-10-19T09:29:59.428Z"
}
```

An on-road price row:

```json
{
  "imageUrl": "https://images.91wheels.com/assets/b_images/gallery/heromotocorp/splendor-plus/heromotocorp-splendor-plus-0-1780550417.png",
  "recordType": "on-road-price",
  "title": "Hero Splendor Plus Drum Brake OBD2B on-road price in Mumbai",
  "listingId": "26971-188",
  "variantId": "26971",
  "modelId": "5018",
  "url": "https://www.91wheels.com/bikes/heromotocorp/splendor-plus/drum-brake-obd2b",
  "sourceSite": "91wheels.com",
  "country": "IN",
  "vehicleType": "motorcycle",
  "make": "Hero",
  "makeSlug": "heromotocorp",
  "model": "Splendor Plus",
  "modelSlug": "splendor-plus",
  "variant": "Drum Brake OBD2B",
  "variantSlug": "drum-brake-obd2b",
  "fuelType": "Petrol",
  "transmission": "Manual",
  "city": "Mumbai",
  "region": "Maharashtra",
  "priceCity": "Mumbai",
  "price": 86919,
  "currency": "INR",
  "priceType": "on-road",
  "exShowroomPrice": 78094,
  "rtoCharges": 5467,
  "insurance": 3358,
  "onRoadPrice": 86919,
  "scrapedAt": "2026-10-19T09:29:12.664Z"
}
```

A variant row carries the full specification sheet, for example for the Hero Splendor Plus Drum Brake OBD2B: 97.2 cc, 1 cylinder, air cooled, 4 gears, 8.01 PS, 8.05 Nm, 112 kg, 785 mm seat height, drum brakes front and rear, alloy wheels, ex-showroom 77,777 INR in New Delhi.

### How do on-road prices by city work?

The site keeps a price list for each of its 1,053 price cities. For a town with no list of its own it shows the price of a nearby reference city. The actor keeps this visible: `city` is the city you asked for and `priceCity` is the city whose price list was used. An unknown city name is reported, never replaced. Dealers are different: any town with showrooms works, even when it is not in the price-city list.

### Monitor new models and repricing

Switch on **Only new rows (monitor)** and the actor remembers every row it delivered, in a named store of your own account. Scheduled runs with the same **Monitor name** return only rows it has not delivered before, so you pay only for new rows. Add **Report price changes** and a model, variant or on-road price that moved comes back as a `price-change` row with the previous price, the difference and the percentage. Use **Forget seen rows** to start again.

### How does it compare with other Indian bike scrapers?

No other Apify actor targets 91wheels.com, read on 2026-10-19. The closest one covers a neighbouring portal, so this table shows what it returns so you can combine them.

| | 91Wheels Scraper | bovi/bikewale-bikes-scraper |
|---|---|---|
| Site | 91wheels.com | bikewale.com |
| Models with specs | Yes, up to 55 fields | Yes, 12 fields |
| Full variant spec sheets | Yes, up to 70 fields | No |
| On-road breakdown per variant and city | Yes, 1,053 cities | No |
| Dealer showrooms with coordinates | Yes, more than 19,000 | No |
| Upcoming models | Yes | Not stated |
| Monitoring with price-change rows | Yes | No |

Run both next to each other if you want to compare the two portals' new-bike prices.

### Data quality and limits

- The actor covers new vehicles. The site has a used vehicle section, but its robots.txt disallows it, so the actor does not read it.
- Specification values are what the site publishes. A few are clearly wrong at the source (a heavy cruiser listed at 3 kg, a power figure of 24,033 PS). The actor drops values outside a plausible range instead of repeating them, and never guesses a replacement.
- Fill rates over the whole catalogue: power 81 percent and rating 80 percent of models. Scooters have no body type on the site, so `bodyType` is filled for 73 percent of models. For the 9,570 TVS showrooms: pincode and coordinates 100 percent, city 97, region 88, street address 85. Upcoming models carry the price the site shows for them (97 of 98 have one) and an expected launch date.
- Some showrooms have no city on the site (3 percent of TVS), and others sit in towns missing from the price-city list (9 percent of TVS), so their `city` or `region` is left out rather than guessed.
- Photos and brochures are links to the site's own files. They are not downloaded.
- Names and comments of reviewers and question askers are never output. Dealer e-mail addresses are never output.
- Free Apify plans are limited to 10 results per run.

### Use with AI agents (MCP)

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

Example prompt: "List the five cheapest electric scooters on sale in India with battery capacity and range." The agent sends `{ "mode": "models", "vehicleTypes": ["scooter"], "fuelType": "electric", "maxItems": 100 }` and sorts the rows by `price`.

### Run it from code

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('RecordsData/91wheels-scraper').call({
    mode: 'on-road-prices',
    makes: ['TVS'],
    models: ['Jupiter'],
    cities: ['Chennai'],
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].onRoadPrice);
```

You can also call the actor from the Python client, Make, Zapier or n8n, and schedule it from the Apify Console.

### Business use cases

- **Price comparison sites and dealers**: keep a table of ex-showroom and on-road prices per city and compare it with competing portals.
- **Market research**: track how many models each brand sells per segment, which launches are upcoming and how fast electric scooters grow.
- **Lead generation**: build a list of authorised showrooms per brand and city with address and coordinates.
- **Insurance and finance**: use the on-road breakdown (RTO, insurance, ex-showroom) to price loans and policies per city.

### Beyond business use cases

- **Research**: study price spread across Indian cities for the same variant.
- **Personal**: compare two bikes side by side before buying.
- **Non-profit**: map dealer coverage in smaller states.
- **Experimentation**: feed clean specs into a recommendation model.

### Frequently Asked Questions

#### What does the 91Wheels Scraper cover?

It covers the new-vehicle data on 91wheels.com: 530 motorcycle and scooter models (432 on sale and 98 upcoming), 947 variants with specification sheets, on-road prices for 1,053 cities, and more than 19,000 dealer showrooms. It also has a monitor mode that returns only new rows and price changes.

#### Do I need a proxy, a login or an API key?

No. The actor reads the public data the site's own pages use, so it needs no proxy, browser or 91wheels account. You only need an Apify account to start runs, and the free plan returns up to 10 results per run. A proxy field exists only for networks that require one.

#### How do I get the on-road price of a bike in my city?

Choose **On-road prices**, add the brand and model, and put your city in **Cities**. Each variant comes back with ex-showroom price, RTO charges, insurance and the total (plus TCS on premium bikes, where the site lists it). If the site has no price list for your town, `priceCity` shows which nearby city it used.

#### How do I find all electric scooters on sale in India?

Choose **Models**, set **Vehicle types** to scooters and **Fuel** to electric. Each row has battery capacity, range and charging time where the site lists them, plus the ex-showroom price range.

#### Can I list all dealers of one brand?

Yes. Choose **Dealers**, add the brand and leave **Cities** empty. TVS alone has 9,570 showrooms. Add a city to narrow the list, even a small town. Phone numbers come only with **Include dealer phone numbers**.

#### Does it return used bikes?

No. The used vehicle section of the site is disallowed in its robots.txt, so the actor does not read it. It returns new and upcoming models, their variants, prices and dealers.

#### Why does a price differ from what the dealer quotes?

Prices are the ones the site publishes: ex-showroom per variant and an on-road estimate per city. Dealers may add accessories or offers. The site updates prices when manufacturers do, which is why the monitor mode reports changes.

#### Is it legal to scrape 91wheels.com?

The actor reads publicly visible data, does not log in and skips the paths that robots.txt disallows. It outputs no private data: reviewer names, comments and dealer e-mail addresses are left out. The terms of use of the site restrict copying content and automated access, so check them and the law that applies to you before using the data commercially.

#### How much does a run cost?

The actor is billed per result and the Pricing tab of the actor page shows the live rate. Error rows, empty searches and rows skipped by the monitor are never charged.

#### Can I get every model on the site?

Yes. Leave brands and models empty and set **Maximum items** to 600 or more. Free plans stop at 10 results per run.

#### What happens with a typo in a brand or city name?

The run ends with one free error row that says what was not found, with the closest brand names for a brand, so you can correct the input. Nothing is silently replaced.

#### Can I schedule it?

Yes. Create a schedule in the Apify Console with **Only new rows** switched on, and every run returns only new models, variants and changed prices.

### Integrate with any app

The dataset works with Make, Zapier, n8n, Google Sheets, Airbyte, Slack and any tool that reads JSON or CSV. See the [Apify integrations](https://apify.com/integrations) page for the full list.

**Need help?** contact.punkrecordsdata@gmail.com

> **Disclaimer:** this is an independent tool, not affiliated with 91wheels.com. It collects only publicly available data.

# Actor input Schema

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

models = one row per motorcycle or scooter model with specs, price range, ratings and photos. variants = one row per variant with the full spec sheet and ex-showroom price. on-road-prices = one row per variant and city with RTO, insurance and on-road price. dealers = authorised showrooms by brand and city. urls = 91wheels.com addresses you list.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Brand names as written on the site, for example Royal Enfield, Hero, TVS, Bajaj, Honda or Ola Electric. Case does not matter. The brand list is read from the site at run time and an unknown brand is reported with the closest names. Empty means every brand. Used by models, variants, on-road prices and dealers.

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

Model names, for example Classic 350, Splendor Plus, Activa or Raider 125. A name picks the model with that exact name, or every model that contains all its words. With brands it narrows inside them. Used by models, variants and on-road prices.

## `vehicleTypes` (type: `array`):

Motorcycles, scooters or both. Empty means both.

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

Indian city names as written on the site, for example Mumbai, Pune, Bangalore or Hyderabad. on-road-prices: each city is priced (empty means New Delhi). models and variants: the first city sets the price shown (empty means New Delhi). dealers: the cities to list (empty means every city); any town with showrooms works, even a small one. An unknown city is reported, it never silently returns another place. The site prices a small town at its nearest price city, and the row says which one in priceCity.

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

Only motorcycles of these types (any of them). Scooters have no body type on the site. Empty means all types.

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

Only vehicles with this fuel. Any means all fuels.

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

Lowest ex-showroom price in rupees. A model is kept when its price range reaches this value. 0 means no lower limit.

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

Highest ex-showroom price in rupees. A model is kept when its price range starts at or below this value. 0 means no upper limit.

## `modelStatus` (type: `string`):

available = models on sale in India. upcoming = announced models with an expected launch date. both = everything. Variants and on-road prices exist only for models on sale.

## `includeModelDetails` (type: `boolean`):

Reads one extra page per model to add top speed, kerb weight, ground clearance, wheelbase, tank size, warranty, the efficiency range, variant, colour and photo counts, rating and review counts, key features and the brochure link. Turn it off for a faster run with the list data only (rating, description and photos stay).

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

Adds the business phone number of dealer showrooms (dealers mode). Dealer e-mail addresses and the names or comments of reviewers are never output.

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

urls mode. 91wheels.com addresses: a brand page (https://www.91wheels.com/bikes/royalenfield), a model page (/bikes/royalenfield/classic-350 or /scooters/honda/activa-6g), a variant page (/bikes/royalenfield/classic-350/redditch-series-single-channel), a price page (/bikes/royalenfield/classic-350/price-in-pune) or a dealer page (/bike-dealers/heromotocorp/mumbai). Addresses with variant= in them are refused because the site disallows them.

## `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 model, variant 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.

## `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": "models",
  "maxItems": 10,
  "makes": [],
  "models": [],
  "vehicleTypes": [],
  "cities": [],
  "bodyTypes": [],
  "fuelType": "any",
  "modelStatus": "available",
  "includeModelDetails": true,
  "includeContactDetails": false,
  "startUrls": [],
  "onlyNew": false,
  "trackPriceChanges": false,
  "stateKey": "",
  "resetSeen": false,
  "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,
    "makes": [],
    "models": [],
    "vehicleTypes": [],
    "cities": [],
    "bodyTypes": [],
    "priceFrom": 0,
    "priceTo": 0,
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/91wheels-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,
    "makes": [],
    "models": [],
    "vehicleTypes": [],
    "cities": [],
    "bodyTypes": [],
    "priceFrom": 0,
    "priceTo": 0,
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/91wheels-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,
  "makes": [],
  "models": [],
  "vehicleTypes": [],
  "cities": [],
  "bodyTypes": [],
  "priceFrom": 0,
  "priceTo": 0,
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/91wheels-scraper --silent --output-dataset

```

## MCP server setup

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