# Kelley Blue Book Scraper (`parseforge/kelley-blue-book-scraper`) Actor

Scrape Kelley Blue Book vehicle data by year, make, and model. Get MSRP, fair market price, trade-in value, safety scores, consumer reviews, specs, and trim details.

- **URL**: https://apify.com/parseforge/kelley-blue-book-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Automation, E-commerce
- **Stats:** 30 total users, 1 monthly users, 83.7% runs succeeded, 3 bookmarks
- **User rating**: 1.00 out of 5 stars

## Pricing

from $40.99 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Kelley Blue Book Scraper

**Scrape Kelley Blue Book vehicle valuations and data for any car by year, make, and model.** Get fair market price, MSRP, trade-in value, safety scores, consumer reviews, specs, and trim details. No API key needed. Export to CSV, JSON, Excel, or XML.

Kelley Blue Book's website is the go-to source for car valuations, but extracting data manually page by page is slow and error-prone. This scraper reads public KBB vehicle pages directly, returning structured data for any car you specify by year, make, and model. Each run delivers a clean dataset with pricing, ratings, and specs.

| Who uses it | What they scrape Kelley Blue Book for |
|---|---|
| Car dealers | Compare KBB fair market prices against their inventory to set competitive asking prices. |
| Auto researchers | Gather historical and current vehicle valuations for market analysis reports. |
| Data analysts | Build datasets of car specs, safety scores, and consumer reviews for predictive models. |
| Car buyers | Check trade-in values and fair purchase prices before negotiating with a dealer. |

### What it does

This Actor collects Kelley Blue Book vehicle data by year, make, and model, and returns each vehicle as a flat row with pricing, ratings, specs, and reviews.

- 🚗 **Batch lookup:** Provide a list of vehicles by year, make, and model, and the scraper processes them all in one run.
- 📍 **Pinned market:** Optionally enter a ZIP code so KBB uses that market for the lookup instead of geolocating the IP the run comes out of.
- 📊 **Full vehicle profile:** Each result includes MSRP, fair market price, trade-in value, safety crash test scores, consumer reviews, specs, and trim details.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Kelley Blue Book data

**📈 Build a vehicle valuation database.**

A used car dealer runs the scraper weekly with their inventory list to track KBB fair market prices and adjust listings.

**🔍 Analyze safety and specs across models.**

An auto researcher collects crash test scores and specs for all 2024 sedans to compare safety ratings.

**💰 Estimate trade-in values for customers.**

A car buyer inputs their current vehicle's year, make, and model to get a trade-in value before visiting a dealership.

**📊 Monitor consumer review trends.**

A market analyst scrapes consumer reviews for popular SUVs to identify common complaints and praises.

### Why choose this scraper

|  | What you get |
|---|---|
| **Structured data** | Every vehicle returns a consistent schema with pricing, ratings, specs, and reviews. |
| **No API key** | Scrapes public KBB pages directly, no registration or API token required. |
| **Every trim** | One row per trim, each with its own fair purchase price, original MSRP and EPA ratings. |
| **Batch processing** | Look up dozens of vehicles in a single run by providing a list. |

### How it compares

This scraper focuses on vehicle valuation data (pricing, ratings, specs) from Kelley Blue Book, while the competitors below target car listings for sale.

| Feature | ParseForge | Kelley Blue Book Scraper | KBB Cars for Sale Scraper - Kelley Blue Book Listings | Kbb Cars Search Scraper |
|---|---|---|---|---|
| Vehicle valuations (MSRP, trade-in, fair market) | Yes | Yes | Not listed | Not listed |
| Safety crash test scores | Yes | Yes | Not listed | Not listed |
| Consumer reviews | Yes | Yes | Not listed | Not listed |
| Car listings for sale (price, mileage, VIN) | Not listed | Not listed | Yes | Yes |
| Dealer info and deal rating | Not listed | Not listed | Yes | Not listed |
| Batch lookup by year, make, model | Yes | Not listed | Not listed | Not listed |
| One row per trim, not per model | Yes | Not listed | Not listed | Not listed |

### Configure the run

Drive the Actor from a list of vehicles (year, make, model) or a single KBB URL. Optionally set a ZIP code to pin the market and a maximum number of vehicles to collect. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "vehicles": [
    {
      "year": 2022,
      "make": "toyota",
      "model": "camry"
    },
    {
      "year": 2020,
      "make": "ford",
      "model": "f-150"
    }
  ],
  "maxItems": 10
}
```

A larger pull:

```json
{
  "vehicles": [
    {
      "year": 2022,
      "make": "toyota",
      "model": "camry"
    },
    {
      "year": 2020,
      "make": "ford",
      "model": "f-150"
    }
  ],
  "maxItems": 200
}
```

### Pricing

Pay-per-event: a **$0.005 run start fee** plus **$0.05466 per result** collected. Both are charged only once the run delivers real vehicle data, so a run that returns nothing costs you **$0.00**.

| Results collected | Approximate cost |
|---|---|
| 0 results (blocked or invalid input) | $0.00 |
| 100 results | $5.47 |
| 1,000 results | $54.67 |
| 10,000 results | $546.61 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Kelley Blue Book Scraper](https://apify.com/parseforge/kelley-blue-book-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Kelley Blue Book through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/kelley-blue-book-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your vehicle list has correct year, make, and model values. Also verify that the KBB URL is valid and points to a vehicle page.

**The scraper is returning incomplete data for some vehicles.**

Some vehicle pages may lack certain fields (e.g., safety scores for older models). The scraper returns what is available.

**How do I scrape a specific trim level?**

Include the trim in the vehicle list if possible, or use a direct KBB URL that specifies the trim.

**The run is taking too long.**

Reduce the maximum number of vehicles in the input. Large batches take longer to process.

**I'm getting an error about rate limiting.**

Kelley Blue Book blocks datacenter proxies, so the Actor goes out directly by default and falls back to US residential proxies on its own if that route is refused; leaving the Proxy configuration field switched off is the right setting. Vehicles that stay blocked are written to the dataset with an `error` field and are never charged.

### FAQ

| Question | Answer |
|---|---|
| Do I need an API key or login to use this scraper? | No. The scraper reads public Kelley Blue Book pages directly, so no API key or account is required. |
| Can I scrape pricing for multiple vehicles at once? | Yes. Provide a list of vehicles with year, make, and model in the input, and the scraper will process them all in one run. |
| What data does each vehicle result include? | Each result includes MSRP, fair market price, trade-in value, safety crash test scores, consumer reviews, specs, and trim details. |
| Does the ZIP code change the prices? | No. KBB publishes its fair purchase price and MSRP as national figures, so the ZIP only pins the market KBB assumes for the lookup rather than letting it geolocate the run's IP address. |
| What is the maximum number of vehicles I can scrape per run? | You can set a maximum up to 1,000,000 vehicles per run, but be mindful of your Apify platform limits. |
| Can I use a direct KBB URL instead of a vehicle list? | Yes. If you provide a single KBB URL (e.g., for a specific vehicle page), the scraper will use that instead of the list. |
| What export formats are supported? | You can export the dataset to CSV, JSON, Excel, or XML from the Apify platform. |
| Is this scraper legal to use? | Scraping public data from websites is generally legal, but you should review Kelley Blue Book's terms of service and respect their robots.txt. |
| How often can I run the scraper? | There is no hard limit from the scraper itself, but frequent runs may be rate-limited by KBB. We recommend spacing runs out. |
| What if a vehicle is not found? | The scraper will skip vehicles that return no data and continue with the rest. Check the run log for details. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Kelley Blue Book Co., Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `vehicles` (type: `array`):

List of vehicles to look up. Each entry requires year, make, and model. If provided, the startUrl field is ignored.

## `startUrl` (type: `string`):

KBB URL for a specific vehicle page (e.g. https://www.kbb.com/toyota/camry/2022/). Used when vehicles list is empty.

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

How many vehicles to collect per run. Free users: limited to 10 results (preview). Paid users: up to 1,000,000.

## `zipCode` (type: `string`):

Five-digit US ZIP code, sent to KBB as the market for the lookup instead of letting it geolocate the IP the run comes out of. Measured 2026-09-07: KBB's valuations are national figures, so no field in the output currently changes with the ZIP — set it only if you want the market pinned rather than inferred.

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

Proxy used to reach Kelley Blue Book. Leave it off: KBB's Akamai edge denies Apify's datacenter pool outright, and the actor already falls back to US residential on its own if the direct route is blocked. Set a group here only to force a specific pool.

## Actor input object example

```json
{
  "vehicles": [
    {
      "year": 2022,
      "make": "toyota",
      "model": "camry"
    },
    {
      "year": 2020,
      "make": "ford",
      "model": "f-150"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "vehicles": [
        {
            "year": 2022,
            "make": "toyota",
            "model": "camry"
        },
        {
            "year": 2020,
            "make": "ford",
            "model": "f-150"
        }
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/kelley-blue-book-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 = {
    "vehicles": [
        {
            "year": 2022,
            "make": "toyota",
            "model": "camry",
        },
        {
            "year": 2020,
            "make": "ford",
            "model": "f-150",
        },
    ],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/kelley-blue-book-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 '{
  "vehicles": [
    {
      "year": 2022,
      "make": "toyota",
      "model": "camry"
    },
    {
      "year": 2020,
      "make": "ford",
      "model": "f-150"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parseforge/kelley-blue-book-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/kelley-blue-book-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/x16IiBXPRcLaMF3oJ/builds/wo9anUjvoBZuD9Fvw/openapi.json