# CarWale Scraper — India Used Car Prices, Specs & Dealers (`oswaldocarabano/carwale-scraper`) Actor

Scrape used-car listings from CarWale.com (India): asking price, CarWale market valuation, new on-road price, km, fuel, transmission, owners, body type, city, dealer and photos. Optional detail pages add specs, features, insurance and price rating. Dealer list output too. No login.

- **URL**: https://apify.com/oswaldocarabano/carwale-scraper.md
- **Developed by:** [Oswaldo Carabano](https://apify.com/oswaldocarabano) (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 $0.85 / 1,000 car listings

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## CarWale Scraper — India used car prices, specs and dealers

**Scrape used-car listings from CarWale.com, one of India's largest car
marketplaces, into a clean dataset or an API.** Around 108,000 used cars across
India (measured on the live site), from dealers and private owners, in every
city CarWale covers: Delhi, Mumbai, Bangalore, Pune, Hyderabad, Chennai,
Kolkata, Ahmedabad and more.

Every row carries the asking price, **CarWale's own market valuation for that
exact car**, the new on-road price, the gap between asking and market price in
percent, kilometres, fuel, transmission, owners, body type, city and area, the
seller type, the dealer and the photos. Turn on detail pages and each car also
gets colour, registration, insurance, engine, power, torque, mileage, the full
spec sheet, the feature list and CarWale's price rating (great / fair / high).

**No login. No cookies. No browser. No proxy needed.** $0.85 per 1,000 cars.

***

### What you can use this for

| If you are… | You want |
|---|---|
| Building an **India used car price dataset**, a second-hand car price checker or a valuation model | asking price, CarWale market valuation and new on-road price on the same row |
| Doing **dealer lead generation** in India | the Dealers output: one row per dealership with name, logo, city, areas, stock size, price range and makes |
| Tracking **used car market data** by city, brand or fuel | filters for city, make, seller type, fuel, transmission, owners, price and age |
| Pricing trade-ins or auctions | `price_vs_market_pct` tells you how far each ask is above or below market |
| Comparing specs across listings | engine, power, torque, mileage, drivetrain and the full spec sheet from detail pages |
| Researching EV and CNG adoption | fuel and bi-fuel (`additional_fuel`) on every row |

***

### What actually arrives in a row

A listing row always has the same **96 keys** (a key with no data is `null`,
never missing). **The median row has 41 populated fields without detail pages
and 72 with them.**

Every percentage on this page was measured against the live site on
**23 Sep 2026**, and every one carries its sample size. **We do not promise a
field we have not measured.**

#### Always there — 100% (n = 653 cars, 12 searches, 8 cities + national)

`listing_id` · `url` · `title` · `make` · `model` · `model_family` · `variant`
and their CarWale ids · `year` · `price_inr` · `price_text` · `km_driven` ·
`fuel_type` · `transmission` · `body_style_id` · `city` · `seller_type` ·
`seller_name` (dealers) · `emi_from_inr`

#### Usually there

| Field | Fill rate | n |
|---|---:|---:|
| `trim` | 99.7% | 653 |
| `seating_capacity` | 97.5% | 653 |
| `key_features` | 97.5% | 653 |
| `owners` | 95.7% | 653 |
| `area` (neighbourhood) | 87.6% | 653 |
| **`market_price_inr`** (CarWale valuation) | **85.3%** | 653 |
| **`new_on_road_price_inr`** | **84.8%** | 653 |
| `images` and `image_url` — dealers | 100% | 205 |
| `images` and `image_url` — private owners | 37.5% | 448 |
| `key_highlights` — dealers | 88.3% | 205 |
| `dealer_logo_url` — dealers | 63.4% | 205 |
| `tags` ("Great Price", "Home Test Drive"…) | 39.1% | 653 |
| `is_finance_eligible` | 13.3% | 653 |
| `additional_fuel` (CNG/LPG bi-fuel) | 5.8% | 653 |

`body_type` is filled for the nine body styles we matched against CarWale's
own structured data (Sedan, Hatchback, SUV, MPV/MUV, Compact Sedan, Compact
SUV, Sub-Compact SUV, Full-Size SUV, SUV Coupe). For the rare ones we could not
verify it is `null` from search results and is filled from the detail page when
you turn detail pages on. We do not guess.

#### What we do NOT promise

`drivetrain` from search results, a trusted-dealer flag, booking status and a
listing phone number came back empty in **0 of 653** cars, so they are not
promised from search results.

***

### Detail pages: what they add, and what they cost

`includeDetails` opens each car's page. Measured on the local verification
runs (n = 100 dealer cars in Delhi, n = 30 private cars in Pune):

| Field | Dealers | Private owners |
|---|---:|---:|
| `color`, `manufacture_month`, `last_updated_at`, `specifications` | 100% | 100% |
| `features` | 98% | 100% |
| `engine`, `drivetrain` | 94% | 100% / 47% |
| `max_torque`, `max_power` | 78% / 72% | 100% |
| `registration_type`, `owners_text` | 98% | 100% / 97% |
| `registration_number` | 98% | *withheld by default* |
| `insurance_type` | 86% | 27% |
| `highlights` | 84% | 0% |
| `price_rating` (great / fair / high price) and `market_price_range_text` | 75% | 67% |
| `seller_note` (phones removed) | 73% | *withheld by default* |
| **`dealer_phone`** | **55%** | never |
| `mileage` | 35% | 90% |

**A detail page costs about 24× a search result**: one page per car instead of
one request per 24 cars, and 64 KB against 275 bytes per car. That is why detail
pages are **off by default** and billed as their own event.

***

### Dealers: a second output, no extra requests

Set **Output type** to *Dealers* and you get one row per dealership found in
your search: `dealer_name`, `dealer_logo_url`, `city`, `areas`, `listings_seen`,
`min_price_inr` / `median_price_inr` / `max_price_inr`, `makes` and a sample
listing. It is built from the same search results, so it costs no extra
requests.

***

### Privacy: private sellers are people

**48.3% of CarWale's national stock is sold by private owners** (52,171 of
107,995 on 23 Sep 2026; 21–32% in the big cities). A private seller's listing
carries their name, and their detail page carries their registration number and
notes.

| | Dealer | Private owner |
|---|---|---|
| Car data (price, km, specs, photos…) | always | always |
| Name, id, phone, registration number, notes | always | **withheld by default** |

Withheld rows are marked `seller_contact_redacted: true`. Turn on
`includePrivateSellerContact` only if you have a lawful basis to process
personal data. Phone numbers typed inside free text (notes, highlights) are
removed on every row, whoever the seller is.

***

### Input

Run it with **no input** and you get 50 cars from all of India, cheapest first,
in a few seconds. The most useful settings:

| Setting | What it does |
|---|---|
| `city` | one of 17 cities, or empty for all of India |
| `make` | one of 45 makes |
| `startUrls` | any CarWale used-car search page, e.g. `https://www.carwale.com/used/mumbai/hyundai-creta/` |
| `sellerType` | dealers, private owners or both |
| `fuelType`, `transmission`, `owners`, `minPriceLakh`, `maxPriceLakh`, `maxAgeYears` | filters, each checked against CarWale's own counters |
| `sortBy` | price or kilometres, ascending or descending |
| `maxItems` | how many cars (or dealers) to deliver |
| `includeDetails` | add the detail-page fields above |
| `outputType` | `listings` or `dealers` |

**Going deep.** CarWale pages through at most about 34,000 results per search.
When your search matches more, the actor splits it into price bands so you still
reach the whole stock.

**Kilometre filter:** CarWale ignores it (the result count does not change), so
the actor does not offer it rather than pretend.

***

### Output example

A real row from 23 Sep 2026 (dealer name replaced), trimmed to the main fields:

```json
{
  "record_type": "listing",
  "listing_id": "D7350280",
  "url": "https://www.carwale.com/used/mumbai/maruti-suzuki-alto/q412kbdq/",
  "title": "Maruti Suzuki Alto LXi BS-III",
  "make": "Maruti Suzuki",
  "model": "Alto [2005-2010]",
  "year": 2008,
  "price_inr": 79000,
  "market_price_inr": 178472,
  "new_on_road_price_inr": 356609,
  "price_vs_market_pct": -55.7,
  "km_driven": 50000,
  "fuel_type": "Petrol",
  "transmission": "Manual",
  "owners": 1,
  "body_type": "Hatchback",
  "city": "Mumbai",
  "area": "Santacruz(E)",
  "seller_type": "dealer",
  "seller_name": "Example Motors",
  "emi_from_inr": 1421,
  "key_features": ["Manual Air Conditioner", "Engine Immobiliser", "Child Safety Lock"],
  "seller_contact_redacted": false,
  "detail_scraped": false
}
```

***

### Pricing

Pay per event. You pay for cars delivered, **never for error rows and never
twice for the same car in a run**.

| Event | Price |
|---|---:|
| Car listing | $0.00085 |
| Car detail page (only with `includeDetails`) | $0.0015 |
| Dealer (only with Output type *Dealers*) | $0.001 |
| Actor start | $0.00001 (platform minimum) |

1,000 cars cost **$0.85**; with detail pages, **$2.35**. If you set a maximum
cost for the run, the actor stops cleanly when it is reached and tells you so in
the status message. You are never charged beyond your limit, and never for a car
that was not delivered.

***

### Reliability

- Plain HTTPS against CarWale's public search data. No browser: 512 MB of memory
  is plenty (measured on Apify: peak 59 MB for the default run, 132 MB for 100
  cars with detail pages).
- The default run (no input) finishes in about 10 seconds; 100 cars with detail
  pages in under a minute.
- If CarWale starts limiting requests, **all** requests pause together and
  resume, instead of hammering the site.
- If you set a short timeout, the actor stops early, delivers what it has and
  finishes green with a message saying what was left.
- A wrong input (an unknown city, a non-CarWale URL, min price above max) ends
  green with an error row explaining what to fix. Nothing is charged.

### FAQ

**Is there an official CarWale API for used cars?**
Not a public one. This actor reads the same public search data the CarWale
website uses and gives it to you as JSON, CSV or Excel, or through the Apify
API, so you can use it as a CarWale used cars API.

**Can I get used car prices for one city or one model?**
Yes. Pick a `city` and a `make`, or paste any CarWale used-car search page into
`startUrls`, for example `https://www.carwale.com/used/pune/maruti-suzuki-swift/`.

**What is `market_price_inr`?**
CarWale's own valuation of that car (model, variant, year, km, city). With the
asking price on the same row, `price_vs_market_pct` tells you how far each ask
is above or below market. It was filled on 85.3% of cars (n = 653).

**Do I get the seller's phone number?**
For dealers, the phone shown on the detail page (55% of dealer cars, it is a
CarWale call-tracking number). For private owners, contact data is withheld
unless you turn on `includePrivateSellerContact`.

**Can I get a list of used car dealers in Delhi, Mumbai or Bangalore?**
Yes: set Output type to *Dealers* and a city. You get one row per dealership
with its stock size, price range and makes, billed per dealer.

**How many cars can I scrape?**
As many as the search has. CarWale pages through about 34,000 results per
search; above that the actor splits the search into price bands automatically.

**Why did my run return an error row and no cars?**
The input could not be used (for example a URL that is not a CarWale used-car
search page, or a minimum price above the maximum), or no car matches the
filters. The row says what to change. Error rows are never charged.

**How fresh is the data?**
Every run reads the live site. `scraped_at` is on every row.

### Data and use

This actor collects publicly visible listing data. You are responsible for how
you use it, including any personal data you choose to enable. To have a listing
removed from future runs, contact us through the Apify issues tab.

# Actor input Schema

## `city` (type: `string`):

Search one city. Leave empty for all of India. For other cities or a specific model, use Start URLs instead.

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

Only cars of this brand. Leave empty for all makes.

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

CarWale used-car search pages to scrape instead of City/Make, e.g. https://www.carwale.com/used/mumbai/hyundai-creta/ . The filters encoded in the page are kept; the other filters below are applied on top.

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

Dealers only, private owners only, or both. Measured on 23 Sep 2026: 48.3% of CarWale's national stock is sold by private owners (21-32% in the big cities).

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

Fuel type filter.

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

Transmission filter. Automatic includes AMT, CVT, DCT, torque converter and EV.

## `owners` (type: `string`):

Only cars with exactly this number of previous owners.

## `minPriceLakh` (type: `integer`):

Lower price bound in lakh rupees (1 lakh = ₹100,000). Leave empty for no minimum.

## `maxPriceLakh` (type: `integer`):

Upper price bound in lakh rupees. Leave empty for no maximum.

## `maxAgeYears` (type: `integer`):

Only cars at most this many years old (by model year).

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

Order in which listings are collected. Price and km orders are stable and page through the results without gaps; CarWale's own 'relevance' order is reshuffled on every request, so deep runs with it return fewer unique cars per page.

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

Stop after this many listings (or dealers, when Output type is Dealers). You are charged per result delivered, never for errors.

## `includeDetails` (type: `boolean`):

Also open each car's page to add colour, registration type, insurance type, manufacture month, last-updated date, engine, power, torque, mileage, the full specification and feature lists, the dealer's phone, seller notes and CarWale's price rating. Charged as an extra event per car and ~24x slower (one page per car instead of one per 24).

## `outputType` (type: `string`):

Listings: one row per car. Dealers: one row per dealership found in the search (name, logo, city, areas, number of cars seen, price range and makes).

## `includePrivateSellerContact` (type: `boolean`):

Private sellers are individuals. By default their name, user id, registration number, phone and notes are withheld (the car data is still delivered and the row is marked seller\_contact\_redacted). Turn on only if you have a lawful basis to process personal data. Dealer data is always included.

## `includeNearbyCities` (type: `boolean`):

CarWale can pad a city search with cars from neighbouring cities. Off by default so every row is from the city you asked for.

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

How many requests run at the same time. Measured: 8 in parallel returned no errors, 3 is the default to stay polite.

## `maxCacheAgeDays` (type: `integer`):

0 always fetches fresh data. When a cache is configured, dealer detail pages newer than this are reused and marked detail\_from\_cache.

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

Not needed: CarWale answers without a proxy. If you set one, it is only used when the site starts refusing requests.

## Actor input object example

```json
{
  "city": "delhi",
  "make": "",
  "startUrls": [],
  "sellerType": "dealer",
  "fuelType": "any",
  "transmission": "any",
  "owners": "any",
  "sortBy": "price_desc",
  "maxItems": 100,
  "includeDetails": true,
  "outputType": "listings",
  "includePrivateSellerContact": false,
  "includeNearbyCities": false,
  "maxConcurrency": 3,
  "maxCacheAgeDays": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Listings, dealers or error rows, one per row.

## `summary` (type: `string`):

Counters of the run: delivered, detail pages, errors, requests and why it stopped.

# 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 = {
    "city": "delhi",
    "sellerType": "dealer",
    "sortBy": "price_desc",
    "maxItems": 100,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("oswaldocarabano/carwale-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 = {
    "city": "delhi",
    "sellerType": "dealer",
    "sortBy": "price_desc",
    "maxItems": 100,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("oswaldocarabano/carwale-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 '{
  "city": "delhi",
  "sellerType": "dealer",
  "sortBy": "price_desc",
  "maxItems": 100,
  "includeDetails": true
}' |
apify call oswaldocarabano/carwale-scraper --silent --output-dataset

```

## MCP server setup

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