# Cars.com Review Scraper (`shahidirfan/cars-review-scraper`) Actor

Extract valuable customer feedback and dealership ratings directly from Cars.com. This tool enables you to analyze customer sentiment, service quality, and market reputation effortlessly. Ideal for automotive market research and competitive analysis to get the insights you need.

- **URL**: https://apify.com/shahidirfan/cars-review-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 11 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Cars.com Review Scraper

Extract comprehensive consumer reviews and ratings from Cars.com for any vehicle make, model, and year. Get detailed insights into real owner experiences, ratings breakdowns, and recommendations to make informed automotive decisions.

### Why Choose This Scraper?

- **Fast & Efficient** - Optimized for speed with intelligent pagination handling
- **Comprehensive Data** - Extract review titles, ratings, author info, detailed feedback, and category-specific ratings
- **Clean Output** - Duplicate-safe records with null/empty values removed from output items
- **Easy Configuration** - Simple input parameters: just specify the car make, model, and year
- **Production Ready** - Built for reliability with automatic retries and error handling
- **Cost Effective** - Optimized resource usage for minimal compute costs

### What Data Can You Extract?

This scraper retrieves the following information from Cars.com consumer reviews:

- **Review Details**: Title, full review text, publication date
- **Ratings**: Overall star rating (1-5) and detailed category breakdowns
- **Author Information**: Reviewer name and verification status
- **Recommendations**: Whether the reviewer recommends the vehicle
- **Category Ratings**: Individual scores for comfort, interior, performance, value, exterior, and reliability
- **Vehicle Details**: Make, model, and year for every review

### Use Cases

#### Automotive Research & Analysis

- Analyze consumer sentiment for specific vehicle models
- Compare ratings across different model years
- Track vehicle reliability trends over time

#### Market Intelligence

- Monitor competitor vehicle reviews and ratings
- Identify common customer pain points and praise points
- Understand what features buyers value most

#### Content Creation & Journalism

- Gather real owner feedback for automotive articles
- Compile comprehensive vehicle reviews from actual owners
- Research trending vehicles and consumer preferences

#### Data Science & ML Projects

- Build sentiment analysis models on automotive reviews
- Create recommendation systems based on user feedback
- Analyze correlations between ratings and vehicle specifications

### Input Configuration

The scraper supports two configuration methods:

#### Method 1: Direct URL (Recommended for Single Queries)

Provide a direct Cars.com review URL:

```json
{
  "startUrl": "https://www.cars.com/research/toyota-camry-2023/consumer-reviews/",
  "results_wanted": 50
}
```

#### Method 2: Make, Model, and Year (Recommended for Batch Queries)

Specify vehicle details to automatically build the URL:

```json
{
  "make": "honda",
  "model": "civic",
  "year": 2024,
  "results_wanted": 100
}
```

#### Input Parameters

| Parameter | Type | Required | Description | Default |
|-----------|------|----------|-------------|---------|
| `startUrl` | String | No\* | Direct Cars.com review URL | - |
| `make` | String | No\* | Vehicle manufacturer (e.g., "toyota", "ford") | - |
| `model` | String | No\* | Vehicle model (e.g., "camry", "f-150") | - |
| `year` | Integer | No\* | Model year (e.g., 2023, 2024) | - |
| `results_wanted` | Integer | No | Maximum number of reviews to extract | 20 |
| `proxyConfiguration` | Object | No | Proxy settings for requests | Residential proxies |

**Note:** Either provide `startUrl` OR the combination of `make`, `model`, and `year`. The scraper automatically calculates the required number of pages based on `results_wanted`.

### Output Format

Each review is returned as a structured JSON object:

```json
{
  "review_id": "42f31ebfcbcad4f0532c2f98ca8b2adce80ee4c4",
  "title": "Great family sedan with excellent reliability",
  "rating": 4.5,
  "author": "John Smith",
  "reviewer_location": "Austin, Texas",
  "date": "January 10, 2024",
  "review_type": "Owns this car",
  "subject_name": "Camry owner",
  "review_body": "I've owned this Camry for two years now and it has been incredibly reliable. The fuel economy is excellent and the interior is very comfortable for long drives...",
  "rating_breakdown": {
    "comfort": 5,
    "interior": 4,
    "performance": 4,
    "value": 5,
    "exterior": 4,
    "reliability": 5
  },
  "recommendation_summary": "100% of drivers recommend the 2023 Toyota Camry",
  "overall_vehicle_rating": 4.9,
  "page_title": "Used 2023 Toyota Camry LE For Sale $21,495",
  "car_make": "toyota",
  "car_model": "camry",
  "car_year": 2023,
  "url": "https://www.cars.com/research/toyota-camry-2023/consumer-reviews/"
}
```

#### Output Fields

- **`review_id`** - Stable hash ID for deduplication and downstream joins
- **`title`** - Headline or title of the review
- **`rating`** - Overall star rating (1-5 scale, may include decimals)
- **`author`** - Name of the reviewer
- **`reviewer_location`** - Reviewer-reported location when available
- **`date`** - When the review was published
- **`review_type`** - Verification status (e.g., "Owns this car", "Verified Purchaser")
- **`subject_name`** - Review subject label when provided by source
- **`review_body`** - Full text content of the review
- **`rating_breakdown`** - Object containing individual category ratings (comfort, interior, performance, value, exterior, reliability)
- **`recommendation_summary`** - Aggregate recommendation text for the selected model-year
- **`overall_vehicle_rating`** - Aggregate overall rating value for the selected model-year
- **`page_title`** - Source page title used for extraction context
- **`car_make`** - Vehicle manufacturer
- **`car_model`** - Vehicle model name
- **`car_year`** - Model year
- **`url`** - Source URL of the review page

### Examples

#### Example 1: Extract Reviews for a Popular Sedan

```json
{
  "make": "toyota",
  "model": "camry",
  "year": 2023,
  "results_wanted": 50
}
```

#### Example 2: Get Reviews for an Electric Vehicle

```json
{
  "make": "tesla",
  "model": "model_3",
  "year": 2024,
  "results_wanted": 100,
  "max_pages": 15
}
```

#### Example 3: Research Luxury Vehicle Feedback

```json
{
  "make": "bmw",
  "model": "x5",
  "year": 2023,
  "results_wanted": 75
}
```

#### Example 4: Using Direct URL

```json
{
  "startUrl": "https://www.cars.com/research/ford-f_150-2023/consumer-reviews/",
  "results_wanted": 200
}
```

### Performance & Cost Optimization

This scraper is optimized for both speed and cost efficiency:

- **Average Runtime**: 20 reviews in under 60 seconds
- **Proxy Usage**: Residential proxies recommended for best reliability
- **Concurrent Requests**: Balanced concurrency to avoid rate limiting
- **Memory Efficiency**: Streaming data processing for large extractions

#### Tips for Optimization

1. **Set Realistic Limits**: Use `results_wanted` to control runtime and costs (pages are auto-calculated)
2. **Batch Processing**: For multiple vehicles, run separate scraper instances
3. **Proxy Selection**: Residential proxies provide best success rates

### Pagination & Data Collection

The scraper automatically handles pagination with intelligent page calculation:

- **Auto-calculates pages** based on `results_wanted` (assumes ~10 reviews per page + safety buffer)
- Starts from page 1 of the review listing
- Continues to subsequent pages until reaching `results_wanted`
- **Stops immediately** when target is reached (no wasted requests)
- Intelligently detects when no more reviews are available
- Deduplicates reviews to ensure unique results

### Error Handling & Reliability

Built-in features ensure reliable data extraction:

- **Automatic Retries**: Failed requests are retried up to 3 times
- **Session Management**: Uses session pools to maintain consistent connections
- **Graceful Degradation**: Handles missing fields without crashing
- **Proxy Rotation**: Automatic proxy rotation to avoid blocking

### Best Practices

#### For Accurate Data Collection

- Always verify the make/model/year combination exists on Cars.com
- Start with smaller `results_wanted` values for testing
- Monitor initial runs to ensure correct URL formatting

#### For Large-Scale Scraping

- Break large jobs into smaller batches
- Use appropriate `max_pages` limits to prevent overruns
- Consider scraping during off-peak hours for better performance

#### For Data Quality

- Review the first few results to ensure proper extraction
- Check that rating breakdowns are being captured correctly
- Validate that pagination is working as expected

### Frequently Asked Questions

**Q: How do I find the correct make/model format?**\
A: Visit Cars.com and navigate to the vehicle's review page. The URL format shows the exact make/model format needed (e.g., "toyota-camry", "ford-f\_150").

**Q: What if a vehicle has no reviews?**\
A: The scraper will complete successfully but return an empty dataset. Always verify the vehicle has reviews on Cars.com before scraping.

**Q: Can I scrape reviews for multiple vehicles at once?**\
A: This scraper is designed for one vehicle at a time. For multiple vehicles, run separate scraper instances or use the Apify API to batch your requests.

**Q: How are rating breakdowns handled if they're missing?**\
A: The `rating_breakdown` field will be `null` if no category ratings are available for a specific review.

**Q: Is this scraper compliant with Cars.com's terms of service?**\
A: This scraper is designed to collect publicly available data. Always review and comply with Cars.com's terms of service and robots.txt directives.

### Support & Feedback

If you encounter any issues or have suggestions for improvements, please reach out through the Apify platform. We continuously update this scraper to ensure optimal performance and data accuracy.

### Version History

**v1.0.0** - Initial release

- Full review extraction with all metadata
- Pagination support
- Rating breakdown extraction
- Deduplication
- Production-ready reliability

***

**Keywords**: cars.com scraper, car reviews, vehicle reviews, consumer reviews, automotive data, car ratings, vehicle ratings, review scraper, Cars.com API, automotive intelligence, car research, vehicle feedback, owner reviews

# Actor input Schema

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

Direct Cars.com review URL (e.g., https://www.cars.com/research/toyota-camry-2023/consumer-reviews/). If provided, this will be used instead of make/model/year.

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

Car manufacturer (e.g., Toyota, Honda, Ford, Audi). Required if not using startUrl.

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

Car model name (e.g., Camry, Civic, F-150, A3). Use underscores for multi-word models (e.g., 'a3\_e\_tron'). Required if not using startUrl.

## `year` (type: `integer`):

Model year (e.g., 2023, 2022, 2024). Required if not using startUrl.

## `results_wanted` (type: `integer`):

Maximum number of reviews to collect. Set a limit to control runtime and costs.

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

Proxy settings for requests. Residential proxies recommended for better reliability.

## Actor input object example

```json
{
  "startUrl": "https://www.cars.com/research/toyota-camry-2023/consumer-reviews/",
  "make": "toyota",
  "model": "camry",
  "year": 2023,
  "results_wanted": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "make": "toyota",
    "model": "camry",
    "year": 2023,
    "results_wanted": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/cars-review-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 = {
    "make": "toyota",
    "model": "camry",
    "year": 2023,
    "results_wanted": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/cars-review-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 '{
  "make": "toyota",
  "model": "camry",
  "year": 2023,
  "results_wanted": 20
}' |
apify call shahidirfan/cars-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hNXuFVd0eHIAfBWyF/builds/eN5EcWRXn5RfrX0o5/openapi.json