# Kavak Car Listings Scraper (`hgservices/kavak`) Actor

Scrape used car listings from Kavak.com across Mexico, Brazil, Argentina, Chile, and UAE. Extract make, model, year, mileage, price, location, and more. Ideal for price tracking, market research, and inventory monitoring.

- **URL**: https://apify.com/hgservices/kavak.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Kavak Car Listings Scraper — Used Car Data Across Latin America & the Middle East

Extract structured used car inventory from [Kavak.com](https://www.kavak.com) — the largest used car marketplace in Latin America and the Middle East — covering **Mexico, Brazil, Argentina, Chile, and the UAE** from a single Actor.

Get clean JSON with make, model, year, mileage, price, location, and more. Sub-cent per listing. No DOM scraping — data is pulled directly from Kavak's server-rendered payloads for reliability against frontend changes.

---

### Who is this for?

- **Automotive dealers and importers** monitoring competitor pricing across LatAm markets
- **Price aggregator and comparison sites** needing structured inventory feeds
- **Market researchers and analysts** studying used car valuations in Mexico, Brazil, or the UAE
- **Data journalists** covering inflation, purchasing power, or automotive trends in Latin America
- **No-code and automation builders** piping Kavak data into Google Sheets, Zapier, or Make workflows

---

### Why use Kavak Car Listings Scraper?

- **The only Apify Actor covering Kavak's multi-country inventory** — Mexico, Brazil, Argentina, Chile, UAE in one place
- **No DOM scraping** — extracts data directly from RSC (React Server Components) payloads, making it resilient to visual frontend changes
- **Sub-cent per listing** — approximately $0.01–0.02 per page (~24 listings), under $0.001 per car record
- **Multi-country from a single Actor** — switch countries with one dropdown, no separate deployments
- **Anti-bot resilient** — uses Camoufox (stealth Firefox) with Apify proxy rotation to handle Kavak's Cloudflare protection
- **Structured, analysis-ready output** — clean JSON with all listing fields, ready to drop into a spreadsheet, database, or BI tool
- **Filter by make and model** — narrow results to specific vehicles instead of scraping everything
- **Full pagination support** — scrape thousands of listings by increasing the page limit

---

### How to use

1. Open the Actor's input page in Apify Console
2. Select your target **country** (`mx`, `br`, `ar`, `cl`, or `ae`)
3. Optionally enter a **car make** (e.g. `toyota`) and **model** (e.g. `camry`) to filter results
4. Set `maxPages` to control how many pages to scrape (each page ≈ 24 listings)
5. Click **Start**
6. Download results as JSON, CSV, Excel, or connect via the Apify API

**Tip:** Start with Mexico (`mx`) — it has the largest Kavak inventory and is the best country to test filters and validate output before scaling to other markets.

---

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `country` | string | Country to scrape: `mx`, `br`, `ar`, `cl`, `ae` | `mx` |
| `make` | string | Car make filter (e.g. `toyota`) | — |
| `model` | string | Car model filter (e.g. `camry`). Works best when `make` is also set. | — |
| `maxPages` | integer | Max pages to scrape (each page ≈ 24 listings) | `20` |
| `maxResults` | integer | Max total car listings to return | — |

See the **Input** tab for the full schema.

---

### Output

Each car listing returns a JSON object:

```json
{
    "car_id": "abc123",
    "make": "Toyota",
    "model": "Camry",
    "year": 2021,
    "mileage_km": 42350,
    "trim": "2.5 SE",
    "transmission": "Automatic",
    "price": 489900,
    "price_was": "$519,900",
    "currency": "MXN",
    "monthly_payment": "$8,915/mes",
    "location": "Ciudad de Mexico",
    "condition": "used",
    "status": "active",
    "listing_type": "car_listing",
    "seller_type": "dealer",
    "badges": ["Precio bajo"],
    "image_url": "https://images.prd.kavak.io/...",
    "url": "https://www.kavak.com/mx/usado/...",
    "country": "mx"
}
````

Export in JSON, CSV, Excel, or HTML. Connect directly via the Apify API or integrate with Google Sheets, Zapier, or Make.

***

### Data fields

| Field | Description |
|---|---|
| `car_id` | Kavak internal car identifier |
| `make` | Car manufacturer (e.g. Toyota, Nissan, Chevrolet) |
| `model` | Car model (e.g. Camry, Sentra, Spark) |
| `year` | Model year |
| `mileage_km` | Odometer reading in kilometers |
| `trim` | Trim level / variant |
| `transmission` | Transmission type |
| `price` | Current listing price (integer, local currency) |
| `price_was` | Previous price if the listing is discounted |
| `currency` | Currency code: MXN, BRL, ARS, CLP, AED |
| `monthly_payment` | Monthly financing payment string |
| `location` | City or region of the listing |
| `condition` | Vehicle condition (used) |
| `status` | Listing status (active) |
| `listing_type` | Type of listing |
| `seller_type` | Type of seller (dealer) |
| `badges` | Promotional badges (e.g. "Low price", "Precio bajo") |
| `image_url` | Full URL of the primary listing image |
| `url` | Direct link to the Kavak listing page |
| `country` | Country code of the listing |

***

### Pricing and cost

A single page run scrapes ~24 cars and costs approximately **$0.01–0.02** in Apify platform credits — under **$0.001 per car record**.

The Actor uses browser-based scraping with Camoufox (stealth Firefox), which consumes more resources than HTTP-only scrapers but is required to bypass Kavak's anti-bot protection reliably.

***

### Tips

- **Use make/model filters** to pull focused datasets — useful for tracking a specific vehicle across countries or over time
- **Switch residential proxies on** if you encounter 403 errors — Kavak's Cloudflare detection is aggressive on datacenter IPs
- **Increase navigation timeout** if scraping through slow proxy endpoints — the default is already 120s but JavaScript-heavy pages can be slow
- **Schedule runs** via Apify's built-in scheduler to track price changes over time automatically
- **Pipe output to Google Sheets** using the Apify → Google Sheets integration for a live pricing dashboard without any code

***

### FAQ

**Is it legal to scrape Kavak?**
Web scraping of publicly available data is generally legal in most jurisdictions. Always review the target website's Terms of Service and comply with applicable data protection laws. This Actor is provided for research and educational purposes.

**Why am I getting a 403 Forbidden error?**
Kavak uses Cloudflare and aggressive anti-bot measures. Your IP has likely been flagged. Fix:

1. Switch to **Residential Proxies** in the Proxy Configuration section (strongly recommended)
2. If already using residential proxies, try rotating to a different proxy group
3. The Actor already uses **Camoufox** (stealth Firefox) to minimize browser fingerprinting

**The scraper returned no results — what happened?**
Kavak may have updated their RSC payload format. If the parser stops returning results after a previously working run, open an issue on the **Issues** tab. The Actor is actively maintained.

**Can I scrape all listings, not just one page?**
Yes. Increase the `maxPages` input to scrape multiple pages. Each page contains approximately 24 listings. For massive datasets, use filters to segment the crawl.

**Can I get pricing data for a specific car across all countries?**
Yes — run the Actor once per country with the same make/model filters, then merge the datasets. This is useful for cross-market price comparison (e.g. Toyota Corolla pricing: Mexico vs Brazil vs UAE).

**What countries are supported?**
Mexico (`mx`), Brazil (`br`), Argentina (`ar`), Chile (`cl`), and UAE (`ae`).

***

For bugs and feature requests, use the **Issues** tab on this Actor's page. For custom scraping solutions or bulk data needs, reach out through the Apify platform.

# Actor input Schema

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

Kavak country to scrape listings from.

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

Optional car make filter (e.g. "toyota"). Leave empty for all makes.

## `model` (type: `string`):

Optional car model filter (e.g. "camry"). Works best when make is also set.

## `maxPages` (type: `integer`):

Maximum number of pages to scrape. Each page contains approx 24 listings.

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

Maximum number of car listings to return. Leave empty for no limit.

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

Proxy settings for anti-bot protection. Residential proxies are recommended for Kavak.

## Actor input object example

```json
{
  "country": "mx",
  "maxPages": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing the scraped car listings.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/kavak").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("hgservices/kavak").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call hgservices/kavak --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kavak Car Listings Scraper",
        "description": "Scrape used car listings from Kavak.com across Mexico, Brazil, Argentina, Chile, and UAE. Extract make, model, year, mileage, price, location, and more. Ideal for price tracking, market research, and inventory monitoring.",
        "version": "0.0",
        "x-build-id": "SeoO6ue14WMZcqEvs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~kavak/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-kavak",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/hgservices~kavak/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-kavak",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/hgservices~kavak/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-kavak",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "country"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "mx",
                            "br",
                            "ar",
                            "cl",
                            "ae"
                        ],
                        "type": "string",
                        "description": "Kavak country to scrape listings from.",
                        "default": "mx"
                    },
                    "make": {
                        "title": "Car Make",
                        "type": "string",
                        "description": "Optional car make filter (e.g. \"toyota\"). Leave empty for all makes."
                    },
                    "model": {
                        "title": "Car Model",
                        "type": "string",
                        "description": "Optional car model filter (e.g. \"camry\"). Works best when make is also set."
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape. Each page contains approx 24 listings.",
                        "default": 20
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of car listings to return. Leave empty for no limit."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for anti-bot protection. Residential proxies are recommended for Kavak.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
