CarDekho API & Scraper
The CarDekho API turns cardekho.com, India's largest car marketplace, into clean JSON in five actions.
🤖 Using an AI assistant? Copy this link into ChatGPT / Claude / Cursor — it reads every endpoint and parameter instantly and tells you if this API fits your use case.
search covers CarDekho's live used-car stock — 62,599 listings nationally on 2026-10-01 and 7,003 in New Delhi, the same numbers the site prints in its own page title in the same minute — across the 677 city surfaces CarDekho itself publishes, and narrows it by brand, model, body type, fuel, gearbox, ownership count, seat count, colour, RTO state of registration, seller type, branded reseller, CarDekho's own certified and luxury shelves, a price band in lakh of rupees, an odometer band, a model-year band and a price-drop band. Every row carries the listing id and canonical URL, the title, brand, model, variant and year, the asking price in rupees with CarDekho's own rupee-lakh string beside it, the odometer both as a number and as printed, fuel, gearbox, body type, how many owners the car has had, the city and locality, the seller's kind and store ids with a maps link, the photo count and lead image, CarDekho's own written price verdict, and its EMI estimate kept in its own field and never passed off as a price. detail adds the overview table as CarDekho groups it — registration year, insurance status, seats, kilometres, RTO, ownership, engine displacement, gearbox, year of manufacture — the complete manufacturer spec tree in the source's own four groups, the feature tree in its five groups, the whole photo gallery, CarDekho's written summary and reasons-to-buy badges, the store's street address and coordinates, and three further prices under their own names: the equivalent new model's on-road price, the new model's floor price, and CarDekho's average for similar cars. dealer_stock returns every car one seller lists, and is the one surface where CarDekho publishes the seller's trading name, street address, pincode and coordinates. filters returns the live filter vocabulary with the number of listings behind every value, including the whole brand to model tree, so you can size a query before you run it and never guess a spelling. cities returns the 677 city slugs CarDekho serves. No CarDekho account, one ReefAPI key and the standard { ok, data, meta, error } envelope.
The money fields, and why the biggest number on the page is not the price
A CarDekho listing page carries four different rupee figures and they do not mean the same thing, so this API never blends them. Fill rates below are over 294 distinct live listings sampled across 28 surfaces: the national list, three cities, CarDekho-partner stock, enterprise stock, direct-owner stock, a branded reseller, the certified and luxury shelves, electric and CNG cars, and every individual filter.
| Field | What it is | How often it was filled |
|---|---|---|
| price_inr | The asking price today, in rupees. CarDekho writes prices in lakh, so the integer was checked against the rupee string the source itself prints in the same row on every single row parsed: 294 matched, 0 mismatched. On detail it was checked a third time against the structured data the listing page publishes: 8 of 8 matched. A zero is returned as null, never as a price. | 294 of 294 |
| price_display | The price exactly as CarDekho printed it, for example "₹41.50 Lakh" or "₹1.20 Crore". Kept beside the integer so the scale is never a question. Of 294 rows, 292 were printed in lakh and 2 in crore. | 294 of 294 |
| new_model_on_road_price_inr | Not this car's price: the on-road price of the equivalent NEW model, which CarDekho shows for comparison. Measured across 8 listings it ran from 1.33 to 2.24 times the asking price, so it is never interchangeable with it. | 8 of 8 detail records |
| similar_cars_average_price_inr | CarDekho's own average asking price for comparable cars, which is what its price verdict is measured against. | 8 of 8 detail records |
| emi.monthly_inr | Not a price: the monthly instalment CarDekho estimates on the rate card its own pages publish, measured at 14.5 % a year over 48 months. Returned with that rate and term beside it. | 287 of 294 |
| msp_inr | CarDekho's own reference figure, which it does not explain. Measured across 60 rows it equalled the asking price on 47 and differed on 13, so it is returned under its own name and never substituted for the price. | 294 of 294 |
| km_driven / km_text | The odometer as a number, parsed from the string the source prints, with that string kept beside it ("40,056"). | 294 of 294 |
| price_saving | Only printed on cars whose asking price CarDekho has cut. The low fill rate is the source's, not a parsing gap. | 34 of 294 |
Every figure above is the source's own. Two of them — the EMI instalment and the new model's on-road price — are numbers CarDekho computes or borrows rather than the price of the car in front of you, which is exactly why they are named for what they are and kept out of the price field. A listing's seller block carries no trading name on a search row (0 of 294); CarDekho publishes the name, street address and pincode on the dealer_stock surface instead.
Real request and response JSON
Captured from the indexed primary action, search, on .
{
"method": "POST",
"url": "https://api.reefapi.com/cardekho/v1/search",
"headers": {
"x-api-key": "$REEF_KEY",
"content-type": "application/json"
},
"body": {
"city": "new-delhi",
"max_results": 20
}
}{
"ok": true,
"meta": {
"api": "cardekho",
"endpoint": "search",
"mode": "live",
"latency_ms": 1271.4,
"record_count": 20,
"bytes": 719083,
"cache_hit": false,
"completeness_pct": 100,
"stop_reason": "complete",
"upstream_requests": 1,
"promoted_rows": 1,
"unparsable_rows": 0,
"price_scale_checked": 20,
"price_scale_matched": 20,
"price_scale_mismatched": 0,
"charged_credits": 1,
"version": "1.0.0",
"request_id": "b76403090f7e459d",
"queue_ms": 2.5
},
"data": {
"results": [
{
"listing_id": "bb722773-bb60-4e75-ad6c-debd2b768769",
"listing_number": 5459725,
"url": "https://www.cardekho.com/used-car-details/used-Mercedes-benz-gls-450-4matic-cars-Gurgaon_bb722773-bb60-4e75-ad6c-debd2b768769.htm?adId=34677&adType=1",
"title": "Mercedes-Benz GLS 450 4matic",
"make": "Mercedes-Benz",
"model": "Mercedes-Benz GLS",
"model_name": "GLS",
"variant": "450 4matic",
"year": 2026,
"price_inr": 12600000,
"price_display": "₹1.26 Crore",
"msp_inr": 12600000,
"price_saving": null,
"km_driven": 5200,
"km_text": "5,200",
"fuel_type": "Petrol",
"transmission": "Automatic",
"body_type": "SUV",
"owner_number": null,
"owner_text": "unregistered",
"city": "Gurgaon",
"city_id": 74,
"locality": "Sector 21e",
"seller": {
"name": null,
"kind": "Dealer",
"inventory_type": "partner",
"store_id": "F4386CF7360BCC0692351B689CCCC23D",
"dealer_id": 75651,
"map_link": "https://maps.google.com/?q=28.512213,77.063164"
},
"image": "https://images10.gaadi.com/usedcar_image/5459725/original/processed_25af9f07cefd8582bc708761d610046e.jpg?imwidth=420",
"image_count": 21,
"is_certified": false,
"is_promoted": true,
"has_360_view": false,
"price_verdict": "Great Price",
"price_notes": [
"Test drive car — demo unit , history fully traceable.",
"Only 5k km — lower than 90% of similar GLSs on CarDekho."
],
"trust_tags": [],
"emi": {
"monthly_inr": 312734,
"interest_rate_pct": 14.5,
"months": 48
}
},
{
"listing_id": "d36e7307-3f07-4cfa-a7e6-d79807a3ded0",
"listing_number": 5586511,
"url": "https://www.cardekho.com/used-car-details/used-Mini-cooper-s-cars-New-Delhi_d36e7307-3f07-4cfa-a7e6-d79807a3ded0.htm?adId=34987&adType=41",
"title": "Mini Cooper S",
"make": "Mini",
"model": "Mini Cooper",
"model_name": "Cooper",
"variant": "S",
"year": 2013,
"price_inr": 1600000,
"price_display": "₹16 Lakh",
"msp_inr": 1600000,
"price_saving": null,
"km_driven": 8000,
"km_text": "8,000",
"fuel_type": "Petrol",
"transmission": "Automatic",
"body_type": "Hatchback",
"owner_number": 1,
"owner_text": "first-owner",
"city": "New Delhi",
"city_id": 49,
"locality": "Naraina",
"seller": {
"name": null,
"kind": "Dealer",
"inventory_type": "partner",
"store_id": "3BBDFA7724D3A7BD3ACC1314CF613C5B",
"dealer_id": 613,
"map_link": "https://maps.google.com/?q=28.6263804,77.1333284"
},
"image": "https://images10.gaadi.com/usedcar_image/5586511/original/processed_e8571df65affc020b7f59f5cdae89ddc.jpeg?imwidth=420",
"image_count": 17,
"is_certified": false,
"is_promoted": false,
"has_360_view": false,
"price_verdict": "Below Market",
"price_notes": [
"1st owner , 8k km — documents are clear on this Cooper S.",
"Only 8k km — lower than 91% of similar Coopers on CarDekho."
],
"trust_tags": [],
"emi": null
},
{
"listing_id": "c8f80c38-8f1b-4e06-9bb0-1fbbb2c18c1a",
"listing_number": 5624142,
"url": "https://www.cardekho.com/used-car-details/used-Maruti-ertiga-vxi-cng-cars-New-Delhi_c8f80c38-8f1b-4e06-9bb0-1fbbb2c18c1a.htm",
"title": "Maruti Suzuki Ertiga VXI CNG",
"make": "Maruti Suzuki",
"model": "Maruti Suzuki Ertiga",
"model_name": "Ertiga 2015-2022",
"variant": "VXI CNG",
"year": 2018,
"price_inr": 522568,
"price_display": "₹5.23 Lakh",
"msp_inr": 522568,
"price_saving": null,
"km_driven": 103760,
"km_text": "1,03,760",
"fuel_type": "CNG",
"transmission": "Manual",
"body_type": "MUV",
"owner_number": 2,
"owner_text": "second-owner",
"city": "New Delhi",
"city_id": 49,
"locality": "Rohini Courts",
"seller": {
"name": null,
"kind": "Dealer",
"inventory_type": "enterprise",
"store_id": "91AEF247E71A3928BD40529B82C25E69",
"dealer_id": 87354,
"map_link": "https://maps.google.com/?q=28.71310043335,77.08869934082"
},
"image": "https://images10.gaadi.com/usedcar_image/5624142/original/ff80911456610b30b25cf697d16033bd.JPG?imwidth=420",
"image_count": 41,
"is_certified": false,
"is_promoted": false,
"has_360_view": false,
"price_verdict": "Great Price",
"price_notes": [
"fitness valid — check the full verdict.",
"300-point inspection done. Warranty included."
],
"trust_tags": [],
"emi": {
"monthly_inr": 12971,
"interest_rate_pct": 14.5,
"months": 48
}
}
],
"total_available": 6982,
"returned": 20,
"page": 1,
"page_rows": 20,
"pages_available": 350,
"city": "new-delhi",
"applied_filters": [],
"order_is_stable": false,
"currency": "INR"
}
}What the CarDekho API does
| Action | Description | Concrete use case | Key params |
|---|---|---|---|
| search | Search CarDekho's live Indian used-car stock — 62,595 listings nationally and 7,001 in New Delhi on 2026-10-01, the same numbers the site prints in its own page title in the same minute — across 677 city surfaces. Every row carries the listing id, the canonical URL, the asking price in rupees WITH the source's own ₹-lakh string beside it, the odometer, year, variant, fuel, gearbox, body type, ownership count, the city and locality, the seller kind and store/dealer id, the photo count and lead image, CarDekho's own AI price verdict, and its EMI estimate kept separate from the price. `total_available` is CarDekho's own count for your exact query, so you can see what each filter did. 🔴 Measured limits you should plan around: one upstream page is 20 rows and no page-size parameter works, so `max_results` above 20 costs one request per extra 20; the default relevance ORDER ROTATES between identical calls (three identical calls shared 11/20 then 19/20 rows), so treat a page as a sample, not a cursor — paging itself does not overlap (80 rows, 80 unique ids over four pages); and CarDekho offers NO working sort, so none is exposed. At most two of `model`, `body_type`, `transmission`, `owner`, `seats`, `premium_seller`, `badge` may be combined, because a third makes the source silently drop all of them — ask for three and you get INVALID_PARAM naming them, not a wrong answer. Every filter the source does not echo back is reported in `meta.warnings`. A genuinely empty result is `ok:true` with 0 rows, never an error. | Price-intelligence teams call search to search CarDekho's live Indian used-car stock. | city, make, model, body_type, fuel_type, ... |
| detail | One used-car listing in full, from CarDekho's own listing page state: the asking price in rupees, the overview table as the site groups it (registration year, insurance, seats, kms, RTO, ownership, engine displacement, transmission, year of manufacture), the complete manufacturer spec tree in the source's own four groups (engine & transmission, fuel & performance, suspension/steering/brakes, dimensions & capacity), the feature tree in its five groups, the whole photo gallery, CarDekho's own written summary and price verdict, its reasons-to-buy badges, the store's address and coordinates, and the published WhatsApp route. 🔴 Three further prices are returned under their own names and never as the asking price: the equivalent NEW model's on-road price (measured 2.2× the used price on the same page), the new model's floor price, and CarDekho's average for similar cars. 🔴 A dead id is a soft-404 upstream — HTTP 200 after a redirect to the index — so this action verifies the id came back and returns NOT_FOUND when it did not. CarDekho publishes no VIN and no registration number on this surface; those fields are null, not invented. | Classifieds aggregators call detail to get one used-car listing in full, from CarDekho's own listing page state. | listing_id |
| dealer_stock | Every used car one CarDekho seller currently lists, by the `store_id` that `search` and `detail` return. Measured: one New Delhi store → 27 cars out of the city's 7,001, with the same row shape as `search`, PLUS the seller's own trading name, street address, pincode and coordinates, which CarDekho publishes on this surface and nowhere else. 🔴 CarDekho swallows an unknown store id and answers with the whole city instead, so this action refuses a result whose total equals the unfiltered city total and returns NOT_FOUND — you will never be handed a city's worth of cars as if they were one seller's. | Resale and arbitrage tools call dealer_stock to get every used car one CarDekho seller currently lists, by the `store_id` that `search` and `deta…. | dealer_id, city, max_results, page |
| filters | CarDekho's live filter vocabulary for one city, straight off the search page's own state — 15 facets, every value with the number of live listings behind it, including the whole brand → model tree (`facet=brand` returned Maruti Suzuki 1,364 with Baleno 200, Swift 183, Wagon R 181 underneath in New Delhi). This is the action to call before a `search`: it tells you the exact slugs this engine's enums accept, which brands and models actually have stock in that city, and how big a result each value will give. One upstream request. | Lead-generation teams call filters to get carDekho's live filter vocabulary for one city, straight off the search page's own state. | city, facet |
| cities | CarDekho's own index of the cities that have a used-car surface — 677 English city slugs read from the site's own used-car city sitemap on 2026-10-01. Each entry is the slug to pass as `city` plus the canonical URL. Call this once and cache it: it is the list that keeps you out of the silent wrong door, because an unknown slug makes CarDekho answer with the national list instead of an error. | Price-intelligence teams call cities to get carDekho's own index of the cities that have a used-car surface. | none |
Call search from your stack
curl -X POST https://api.reefapi.com/cardekho/v1/search \
-H "x-api-key: $REEF_KEY" \
-H "content-type: application/json" \
-d '{"city":"new-delhi","max_results":20}'import requests
r = requests.post(
"https://api.reefapi.com/cardekho/v1/search",
headers={"x-api-key": REEF_KEY},
json={
"city": "new-delhi",
"max_results": 20
},
)
print(r.json()["data"])const res = await fetch("https://api.reefapi.com/cardekho/v1/search", {
method: "POST",
headers: {
"x-api-key": process.env.REEF_KEY,
"content-type": "application/json",
},
body: JSON.stringify({
"city": "new-delhi",
"max_results": 20
}),
});
const { ok, data, meta, error } = await res.json();Ask your MCP-connected assistant: call reefapi.cardekho.search with {"city":"new-delhi","max_results":20}.Who uses this API and why
- Indian used-car pricing and residual-value work: pull one brand and model with a model-year and odometer band and read the asking-price distribution, then repeat per city to see how the same Hyundai i20 is priced in Delhi against Mumbai and Bangalore — 7,003, 4,887 and 3,701 live listings respectively on 2026-10-01.
- Dealer versus private supply tracking: the three seller surfaces are separate measured filters and they partition the market exactly — CarDekho-partner 3,606 plus enterprise 1,514 plus direct-owner 1,883 equals the New Delhi total of 7,003 to the unit — so you can size organised retail against private supply city by city.
- Organised-resale competitor monitoring: Cars24 and Spinny stock are separately filterable on CarDekho's own surface (1,093 and 420 listings in New Delhi), and dealer_stock returns one named store's entire inventory with its address and coordinates.
- Market mix in one cheap call: filters returns a live listing count on every brand, model, body type, fuel, gearbox, ownership, seat count, colour, RTO state and price band in a city — SUVs 3,205 against hatchbacks 1,805 and sedans 1,484, petrol 5,161 against diesel 1,311, CNG 430 and electric 98 — with the whole brand to model tree underneath.
- Electrification and alternative-fuel research: fuel is a measured filter with CarDekho's own counts, and nationally it returns 693 electric and 2,677 CNG used cars, each with the full spec tree behind the listing.
Questions developers ask before integrating
How many listings are there, and does the count come from you or from CarDekho?
From CarDekho. Every search returns total_available, which is the source's own count for your exact query. On 2026-10-01 the unfiltered national figure was 62,599 and New Delhi was 7,003, both identical to the numbers cardekho.com printed in its own page title in the same minute. Three independent splits of New Delhi add up exactly: seller type (partner 3,606 plus enterprise 1,514 plus direct-owner 1,883), fuel (petrol 5,161 plus diesel 1,311 plus CNG 430 plus electric 98 plus LPG 1) and gearbox (manual 4,033 plus automatic 2,968) each equal the unfiltered total to the unit.
How many rows can one call return, and how fast?
Up to 100, and this is the honest part: CarDekho serves exactly 20 rows per page and ignores every page-size parameter, so a bigger request costs one more upstream page per extra 20 rows. Measured: 20 rows in a median 1.3 seconds, 60 rows in 6.8 seconds over 4 pages, 100 rows in 9.7 seconds over 6 pages. The response reports how many pages it spent. 100 is the deliberate ceiling — 200 rows measured 18 seconds, which is too slow to offer.
Can I sort the results?
No, and that is a limitation of the source rather than a gap in this API. CarDekho's website shows a seven-option sort dropdown, but six different ways of sending it were measured and none of them actually ordered the results — the list came back in the same unsorted order with the unfiltered count intact. A handle that silently does nothing is worse than no handle, so no sort parameter exists. The dropdown's own options are returned by the filters action, marked as unsupported, so you can see exactly what was tested.
If I call the same search twice, do I get the same rows?
Not exactly, and you should know this before you build a cursor on it. CarDekho's default relevance order rotates: three identical calls one minute apart shared 13 of 20 rows with the first on one run and 20 of 20 on the next, and the three runs together returned 27 distinct cars out of 60 rows. Every response therefore carries order_is_stable: false. Paging within one sweep is clean, though — pages 1 to 4 returned 80 rows and 80 distinct listing ids — and a multi-page request de-duplicates by listing id before returning, so a 60-row request gives 60 different cars.
Do the filters actually narrow the result, or are some of them decoration?
Every filter in this API was measured against the unfiltered total in the same run, and only the ones that moved it are exposed. Measured in New Delhi against 7,003: brand Hyundai 1,115, model Hyundai i20 167, SUV 3,206, diesel 1,312, automatic 2,968, first owner 5,579, five seats 5,687, white 1,915, Delhi RTO 4,506, Cars24 1,094, certified 466, luxury 1,306, 3 to 5 lakh 1,477, 10,000 to 45,000 km 2,520, 2023 to 2026 1,949, a price drop up to 50,000 rupees 248. Sixteen of those reproduced CarDekho's own published facet count to the unit. Nine more parameters that CarDekho accepts with a 200 and then ignores were tested and left out, because a filter that does not bite is worse than no filter at all.
Why can I only combine two of some filters?
Because of a real limit in the source that is worth saying out loud. Seven of the filters — model, body type, gearbox, ownership, seats, branded reseller and the certified or luxury shelf — only work on CarDekho when they are part of the page address, and it accepts at most two of them at a time. Measured: two together returned 1,668 results and the source confirmed both; adding a third returned the full unfiltered 7,003 with no filter applied at all. Rather than hand back that wrong answer, the API refuses the third and names the ones you asked for, so you can drop one or run a second call. The other nine filters stack freely — price, year and odometer together were measured working as one query.
What happens if my filter value is misspelled or does not exist?
You get an error, not a wrong answer — which takes work, because CarDekho does not reject a value it does not recognise. An unknown brand or model returns a successful page with the whole city's stock in it. Every response is checked against the source's own list of the filters it actually applied, and a filter that was quietly dropped becomes an explicit invalid-parameter error naming it. The same applies to cities: an unknown city slug makes CarDekho answer with the national list, so this API compares the city the page says it is showing with the city you asked for and rejects the mismatch. Call cities for the 677 slugs it serves.
What happens if nothing matches my filters?
You get a successful response with an empty results array and the source's own total of 0. An LPG SUV in New Delhi was tested for exactly this and CarDekho's own count agreed. The opposite case is also handled: if CarDekho reports listings and none of them can be read, you get an explicit schema error rather than a quiet empty success.
Does a listing id from search always resolve to the same car in detail?
Yes, measured 8 of 8 in both acceptance runs, and this is checked rather than assumed, because a dead listing on CarDekho answers successfully with its index page instead of a not-found. The API verifies the id came back in the record and returns a clean not-found when it did not, so you never receive the index page dressed up as a car.
Is the seller included, and does it include a name or a phone number?
Partly, and here is exactly where the source stops. Every search row carries the seller's kind — dealer or individual — and the inventory type, 294 of 294, with a maps link on 291 of 294 and CarDekho's store and dealer ids on 256 of 294 (the rest are direct-owner listings, which have no store). What a search row does not carry is a trading name: 0 of 294. The name arrives on the dealer_stock surface, where CarDekho publishes its own store block with the trading name, full street address, pincode and coordinates — pass the store id from a search row. A detail record adds the store's address, coordinates and the published WhatsApp route. A private seller publishes no personal name and no personal phone number anywhere, and none is invented.
What does CarDekho not publish?
No VIN or chassis number, and no registration or plate number — the detail record publishes only whether a registration number exists and the RTO code such as DL10. No listed-at date or days-on-market figure, and the view counter reads zero on every row. No two-wheelers: CarDekho's car site does not list them and this API does not claim them. And no new-car catalogue: this API covers the used-car marketplace only. One field, trust_tags, is present in the response but was an empty list on all 294 sampled rows, which is documented rather than hidden.
Does detail always include the full manufacturer spec sheet?
Almost always, and the exception is the source's. Over 8 detail records the overview table, photo gallery, written summary, registration year, insurance status, RTO code and seller block were filled 8 of 8, and the grouped spec tree and feature tree 7 of 8. The eighth car's model has no manufacturer spec sheet on CarDekho at all, so those two arrive as empty lists rather than as invented values.
What is the CarDekho API?
CarDekho API is a ReefAPI endpoint group for india's largest used-car marketplace: 62,599 live listings across 677 cities, with the asking price in rupees, odometer, variant, ownership count, the full manufacturer spec tree, and dealer, cardekho-partner and direct-owner stock as separate measured surfaces. It returns live JSON through POST requests under /cardekho/v1.
Is the CarDekho API free to try?
Yes. ReefAPI starts with 1,000 free credits, no card required. CarDekho calls use the same shared credit balance as every other ReefAPI engine.