# CarGurus Car Listings Scraper (`crawlerbros/cargurus-scraper`) Actor

Scrape CarGurus car listings with search by make/model/zip/price, fetch single listings by ID, or scrape from a CarGurus search URL. Extracts pricing, deal ratings, mileage, dealer info, and more.

- **URL**: https://apify.com/crawlerbros/cargurus-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

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

## CarGurus Car Listings Scraper

Scrape CarGurus car listings — search by make, model, ZIP code, and price range. Fetch single listings by ID or scrape all results from a CarGurus search URL. Extracts pricing, deal ratings, mileage, dealer info, fuel economy, and more.

### What data can you scrape?

- **Search listings** — find cars by make/model/ZIP/price with sort and filter options
- **Single listing** — full details for any car by its CarGurus listing ID
- **From URL** — paste any CarGurus search URL and scrape all results

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | `search`, `byListingId`, or `byUrl` |
| `make` | select | Car manufacturer (Toyota, Honda, BMW, etc.) |
| `model` | string | Model name (e.g. Camry, F-150) |
| `condition` | select | New, Used, or Certified Pre-Owned |
| `sortBy` | select | Sort order: best_deal, lowest_price, etc. |
| `zipCode` | string | 5-digit US ZIP code |
| `minPrice` | integer | Minimum price in USD |
| `maxPrice` | integer | Maximum price in USD |
| `maxMileage` | integer | Maximum odometer reading |
| `listingId` | string | Listing ID for byListingId mode |
| `url` | string | CarGurus search URL for byUrl mode |
| `maxItems` | integer | Max records to emit (default: 50) |

### Output

```json
{
  "listingId": "listing_12345",
  "vin": "1HGCV1F34KA123456",
  "url": "https://www.cargurus.com/Cars/inventorylisting/vdp.action?listingId=12345",
  "year": 2022,
  "make": "Toyota",
  "model": "Camry",
  "trim": "XSE",
  "price": 28500,
  "dealRating": "Great Deal",
  "mileage": 15000,
  "condition": "Used",
  "exteriorColor": "Midnight Black",
  "interiorColor": "Black",
  "transmission": "Automatic",
  "driveType": "FWD",
  "fuelType": "Gasoline",
  "mpgCity": 28,
  "mpgHighway": 39,
  "dealerName": "Toyota of Springfield",
  "dealerCity": "Springfield",
  "dealerState": "IL",
  "daysOnMarket": 12,
  "photoCount": 24,
  "primaryPhotoUrl": "https://static.cargurus.com/...",
  "recordType": "listing",
  "siteName": "CarGurus",
  "scrapedAt": "2026-05-10T12:00:00+00:00"
}
````

### FAQs

**Do I need a CarGurus account?**
No. CarGurus listings are publicly accessible.

**Why might I get no results?**
CarGurus uses JavaScript rendering for search results. The scraper extracts embedded JSON from HTML pages. Provide a ZIP code for more reliable broad searches. For deterministic smoke tests or exact-listing retrieval, prefer `byListingId` or `byUrl`.

**Why can make-specific searches drift?**
CarGurus sometimes serves a generic result set even when a make filter is present in the URL. The actor still applies client-side filters before emitting records, so an overly specific search can legitimately end up empty. When you need guaranteed output for monitoring, use a direct listing ID or a known-good search URL.

**What deal ratings does CarGurus use?**
Great Deal, Good Deal, Fair Deal, High Price, and Overpriced — based on market comparison.

**How many listings can I scrape?**
Set `maxItems` up to 1000. Pagination is handled automatically.

# Actor input Schema

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

How to find listings.

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

Car manufacturer to filter by.

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

Model name to filter by, e.g. 'Camry', 'F-150'. Leave empty for all models.

## `condition` (type: `string`):

Listing condition filter.

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

Result ordering.

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

5-digit US ZIP code for local search, e.g. '10001'.

## `minPrice` (type: `integer`):

Minimum listing price in USD.

## `maxPrice` (type: `integer`):

Maximum listing price in USD.

## `maxMileage` (type: `integer`):

Maximum odometer reading in miles.

## `listingId` (type: `string`):

CarGurus listing ID from a listing URL.

## `url` (type: `string`):

Paste a CarGurus search results URL to scrape all listings from it.

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

Maximum number of listings to emit.

## Actor input object example

```json
{
  "mode": "byListingId",
  "make": "Toyota",
  "condition": "",
  "sortBy": "best_deal",
  "listingId": "444595478",
  "maxItems": 5
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped CarGurus 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 = {
    "mode": "byListingId",
    "make": "Toyota",
    "condition": "",
    "sortBy": "best_deal",
    "listingId": "444595478",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/cargurus-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 = {
    "mode": "byListingId",
    "make": "Toyota",
    "condition": "",
    "sortBy": "best_deal",
    "listingId": "444595478",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/cargurus-scraper").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 '{
  "mode": "byListingId",
  "make": "Toyota",
  "condition": "",
  "sortBy": "best_deal",
  "listingId": "444595478",
  "maxItems": 5
}' |
apify call crawlerbros/cargurus-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CarGurus Car Listings Scraper",
        "description": "Scrape CarGurus car listings with search by make/model/zip/price, fetch single listings by ID, or scrape from a CarGurus search URL. Extracts pricing, deal ratings, mileage, dealer info, and more.",
        "version": "1.0",
        "x-build-id": "Py3vjfd9vn64Gnd0R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~cargurus-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-cargurus-scraper",
                "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/crawlerbros~cargurus-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-cargurus-scraper",
                "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/crawlerbros~cargurus-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-cargurus-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byListingId",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "How to find listings.",
                        "default": "search"
                    },
                    "make": {
                        "title": "Make (mode=search)",
                        "enum": [
                            "Toyota",
                            "Honda",
                            "Ford",
                            "Chevrolet",
                            "BMW",
                            "Mercedes-Benz",
                            "Audi",
                            "Volkswagen",
                            "Hyundai",
                            "Kia",
                            "Nissan",
                            "Subaru",
                            "Mazda",
                            "Jeep",
                            "Ram",
                            "Dodge",
                            "Tesla",
                            "Lexus",
                            "Acura",
                            "Volvo"
                        ],
                        "type": "string",
                        "description": "Car manufacturer to filter by."
                    },
                    "model": {
                        "title": "Model (mode=search)",
                        "type": "string",
                        "description": "Model name to filter by, e.g. 'Camry', 'F-150'. Leave empty for all models."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "New",
                            "Used",
                            "Certified Pre-Owned"
                        ],
                        "type": "string",
                        "description": "Listing condition filter.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "best_deal",
                            "lowest_price",
                            "highest_price",
                            "lowest_mileage",
                            "newest_year",
                            "oldest_year"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "best_deal"
                    },
                    "zipCode": {
                        "title": "ZIP code (mode=search)",
                        "type": "string",
                        "description": "5-digit US ZIP code for local search, e.g. '10001'."
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 9999999,
                        "type": "integer",
                        "description": "Minimum listing price in USD."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 9999999,
                        "type": "integer",
                        "description": "Maximum listing price in USD."
                    },
                    "maxMileage": {
                        "title": "Max mileage",
                        "minimum": 0,
                        "maximum": 999999,
                        "type": "integer",
                        "description": "Maximum odometer reading in miles."
                    },
                    "listingId": {
                        "title": "Listing ID (mode=byListingId)",
                        "type": "string",
                        "description": "CarGurus listing ID from a listing URL."
                    },
                    "url": {
                        "title": "CarGurus search URL (mode=byUrl)",
                        "type": "string",
                        "description": "Paste a CarGurus search results URL to scrape all listings from it."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to emit.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
