# Cars For Sale Scraper (`parseforge/cars-for-sale-scraper`) Actor

Scrapes car listings from Cars For Sale with filters for make, model, year, price, mileage, and location. Returns each listing as a flat row with price, VIN, dealer info, and specs.

- **URL**: https://apify.com/parseforge/cars-for-sale-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 24 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $23.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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

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

### Cars For Sale Scraper

**Scrape car listings from Cars For Sale by make, model, year, price, mileage, or ZIP code, up to a million per run.** Each listing comes with its price, mileage, VIN, dealer info, and full specs. No login or API key. Export to CSV, JSON, Excel, or XML.

Cars For Sale's website has no public API, and manual browsing is slow. This Actor reads the public search and listing pages directly, filtered by make, model, year, price, mileage, condition, body style, color, transmission, drivetrain, fuel type, and ZIP code, and returns each match in one fixed schema.

| Who uses it | What they scrape Cars For Sale for |
|---|---|
| Car dealers | Monitor competitor pricing and inventory in their local market |
| Market researchers | Track used car price trends by make, model, and region |
| Data analysts | Build datasets of vehicle listings for pricing models |
| Car buyers | Compare listings across multiple criteria to find the best deal |

### What it does

This Actor collects car listings from Cars For Sale by search filters or direct URL, and returns each one as a flat row.

- 🔍 **Search filters:** make, model, year range, price range, max mileage, ZIP code, distance, condition, body style, color, transmission, drivetrain, and fuel type.
- 🔗 **Direct URL:** paste any Cars For Sale search or listing page URL and scrape exactly those results.
- 📊 **Structured output:** each car is returned as a flat row with price, mileage, VIN, dealer, specs, and more.
- 🌐 **Residential proxies:** built-in proxy configuration bypasses bot protection for reliable scraping.

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

### What you can do with Cars For Sale data

**📈 Monitor competitor pricing.**

A dealer runs the Actor daily for their ZIP code and make to see what rivals are charging and adjust their own prices.

**🔎 Find undervalued cars.**

A buyer filters by model, year, and max price to spot listings below market value and contact sellers quickly.

**📊 Analyze market trends.**

A researcher scrapes all listings for a model over several months to track depreciation and demand by region.

**🗺️ Build inventory maps.**

A data analyst collects listings with ZIP codes and dealer info to visualize vehicle availability across a state.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API needed** | Scrape public listing pages without registration or keys |
| **Up to 1M cars** | Collect large datasets in a single run |
| **Flexible filters** | Narrow results by vehicle specs, price, location, and more |
| **Export anywhere** | Save as CSV, JSON, Excel, or XML for analysis |

### How it compares

No other Store actor targets Cars For Sale the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Cars For Sale Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Cars For Sale changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from a direct Cars For Sale URL or from search filters like make, model, year, price, mileage, and ZIP code, and filters run as each listing is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "startUrl": "https://www.carsforsale.com/cars-for-sale/toyota/camry/search",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

A larger pull:

```json
{
  "startUrl": "https://www.carsforsale.com/cars-for-sale/toyota/camry/search",
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

### Pricing

Pay-per-result: **$0.03199 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $3.20 |
| 1,000 results | $31.99 |
| 10,000 results | $319.90 |

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 [Cars For Sale Scraper](https://apify.com/parseforge/cars-for-sale-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 Cars For Sale 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/cars-for-sale-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 filters are not too restrictive. Try removing some filters or using a broader ZIP code and distance. Also ensure the Start URL is correct if provided.

**Why is the Actor timing out?**

Large searches may take longer. Increase the timeout in the Actor's run settings or reduce the maximum number of cars.

**Why are some listings missing data?**

Some listings may have incomplete information on the website. The Actor returns whatever is available, so missing fields will be empty.

**Why am I getting blocked?**

The residential proxy should handle most blocks. If you still see issues, try increasing the proxy rotation or contact Apify support.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape a specific search URL? | Yes, paste the URL into the Start URL field and the Actor will scrape exactly those results, ignoring other filters. |
| How many cars can I scrape in one run? | You can set the maximum number of cars up to 1,000,000 per run. The Actor will stop after reaching that count. |
| Do I need a proxy? | The Actor uses residential proxies by default to avoid bot detection. You can leave the proxy configuration as is. |
| What filters are available? | You can filter by make, model, year range, price range, max mileage, ZIP code, distance, condition, body style, color, transmission, drivetrain, and fuel type. |
| What data does each listing include? | Each row includes price, mileage, VIN, dealer information, and full vehicle specs such as engine, transmission, and features. |
| Can I export the results? | Yes, you can export the dataset as CSV, JSON, Excel, or XML directly from the Apify platform. |
| Is this legal? | You should only scrape public data in compliance with the website's terms of service and applicable laws. Apify provides tools but you are responsible for your use. |
| How often can I run this Actor? | You can schedule runs as frequently as you need, but be mindful of the website's load and your Apify plan limits. |

### 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 Carsforsale.com, 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

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

Direct URL to a carsforsale.com search or listing page. If provided, filters below are ignored.

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

How many cars to collect per run.

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

Vehicle manufacturer to filter by (e.g. Toyota, Ford, Honda). Used when no Start URL is provided.

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

Vehicle model to filter by (e.g. Camry, F-150, Civic).

## `yearMin` (type: `integer`):

Minimum model year (e.g. 2018).

## `yearMax` (type: `integer`):

Maximum model year (e.g. 2024).

## `priceMin` (type: `integer`):

Minimum asking price in USD.

## `priceMax` (type: `integer`):

Maximum asking price in USD.

## `mileageMax` (type: `integer`):

Maximum odometer reading in miles.

## `zip` (type: `string`):

ZIP code for proximity-based search.

## `distance` (type: `integer`):

Search radius in miles from the ZIP code.

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

Vehicle condition filter.

## `bodyStyle` (type: `string`):

Vehicle body style filter.

## `color` (type: `string`):

Exterior color filter.

## `transmission` (type: `string`):

Transmission type filter.

## `drivetrain` (type: `string`):

Drivetrain type filter.

## `fuelType` (type: `string`):

Fuel type filter.

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

Residential proxy required to bypass bot protection. Leave as default.

## Actor input object example

```json
{
  "startUrl": "https://www.carsforsale.com/cars-for-sale/toyota/camry/search",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "startUrl": "https://www.carsforsale.com/cars-for-sale/toyota/camry/search",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/cars-for-sale-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 = {
    "startUrl": "https://www.carsforsale.com/cars-for-sale/toyota/camry/search",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/cars-for-sale-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 '{
  "startUrl": "https://www.carsforsale.com/cars-for-sale/toyota/camry/search",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call parseforge/cars-for-sale-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/cars-for-sale-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/GMDAt8giXQPfWk8L0/builds/OJPhNhhL8QqzGhjgn/openapi.json