# DealerRater Scraper - Car Dealer Reviews & Leads (`scrapesage/dealerrater-scraper`) Actor

Scrape DealerRater car dealerships by state, make, city or URL: name, phone, website, full address, star rating, review count, review samples, salespeople and a 0-100 lead score.

- **URL**: https://apify.com/scrapesage/dealerrater-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 dealer record scrapeds

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

## DealerRater Scraper — Car Dealer Reviews, Ratings & Leads

Extract **complete DealerRater dealership data** — the fields other scrapers skip: the dealer's **own website**, **phone numbers**, **full street address**, **overall star rating**, **review count**, **recent review samples**, and the **salespeople listed on every profile**. Turn 27,000+ U.S. car dealerships into rich, scored **automotive B2B leads** — or scrape individual salesperson profiles as recruiter / sales leads.

No login, no API key, no browser — fast server-rendered HTML extraction over a residential proxy.

### Why this DealerRater scraper?

Most "auto dealer lead" tools just re-scrape Google Maps pins — so they miss the reputation data buyers actually want and have no staff information. This actor pulls the **DealerRater profile itself**: the verified review reputation, the dealer's real website, and the named salespeople.

| Data | Google-Maps lead scrapers | This actor |
|---|---|---|
| Dealer name + full street address | ✅ | ✅ |
| Phone number(s) | partial | ✅ |
| Dealer's **own website** (lead wedge) | ❌ | ✅ |
| Overall **star rating** + review count | partial | ✅ |
| Recent **review samples** (title, rating, date, author) | ❌ | ✅ |
| **Salespeople** on the profile (name, profile, review count) | ❌ | ✅ |
| Makes / brands sold | ❌ | ✅ |
| Contact **emails** (from the dealer's website) | ❌ | ✅ opt-in |
| Standalone **salesperson** lead records | ❌ | ✅ opt-in |
| Lead score (0–100) | ❌ | ✅ |
| Monitor mode — only new / changed dealers | ❌ | ✅ |

### Use cases

- **Lead generation** — dealerships are active B2B buyers: reputation-management & review software, dealer-management systems (DMS), CRM & digital-retail tools, F&I products, floor-plan financing, parts/tire/warranty vendors, signage, and marketing agencies. Filter by state, make and rating, then score and contact every lead.
- **Reputation & competitor intelligence** — track ratings, review counts and review velocity for dealers in any market; monitor your own group vs. the competition.
- **Automotive recruiting** — scrape salesperson profiles (name, job title, dealership, review count) as a sourcing list for dealer recruiters.
- **Market mapping** — build a complete directory of dealerships by brand and metro, with contact details and reputation.
- **Data enrichment** — match dealers to your CRM by name + address and append website, phone, rating and staff.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **DealerRater Scraper**, pick **States** and **Makes** (or paste DealerRater URLs), and click **Start**.
3. Watch dealer leads stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "states": ["Texas"],
    "makes": ["Toyota", "Honda"],
    "city": "Austin",
    "maxItems": 100,
    "maxReviewsPerDealer": 10,
    "enrichEmails": false,
    "monitorMode": false
}
````

- **states** — U.S. states to scrape (full name or 2-letter code).
- **makes** — vehicle brands (`Toyota`, `Ford`, `BMW`, `Tesla`, …). Each state is crossed with each make. Leave empty to scan **all major makes** in the chosen states (dealers are deduplicated).
- **city** *(optional)* — keep only dealerships in this city. Dealers are listed state-wide, so raise **maxPagesPerSearch** when filtering by city.
- **searchUrls** *(advanced)* — paste DealerRater dealer pages (`/dealer/…-review-ID/`), salesperson pages (`/sales/…-review-ID/`), or directory pages (`/directory/State/Make/`). Salesperson URLs produce standalone salesperson lead records.
- **minRating / minReviewCount** — quality filters.
- **maxReviewsPerDealer** *(default 10)* — review samples embedded per dealer (same page, no extra cost).
- **enrichEmails** *(default false)* — crawl each dealer's own website (home + contact/about, max 3 pages) for emails, phones and socials.
- **monitorMode** *(default false)* — output only new / changed records (see below).
- **maxItems** *(default 100)*, **maxPagesPerSearch** *(default 10)*, **maxConcurrency**, **maxAttemptsPerPage**, **proxyConfiguration**.

### Output

One record per dealership (`type: "dealer"`), plus optional salesperson lead records (`type: "salesperson"`):

```json
{
    "type": "dealer",
    "dealerId": 4117,
    "name": "Daytona Nissan",
    "url": "https://www.dealerrater.com/dealer/Daytona-Nissan-review-4117/",
    "website": "https://www.daytonanissan.com",
    "phone": "(386) 492-8775",
    "phones": ["(386) 492-8775", "(386) 492-8187"],
    "street": "950 N. Tomoka Farms Rd.",
    "city": "Daytona Beach",
    "state": "FL",
    "postalCode": "32124",
    "country": "US",
    "makes": ["Nissan"],
    "rating": 4,
    "reviewCount": 251,
    "salespeopleCount": 12,
    "salespeople": [
        { "employeeId": 702202, "name": "Rafael Rios", "profileUrl": "https://www.dealerrater.com/sales/Rafael-Rios-review-702202/", "reviewCount": 36 }
    ],
    "reviews": [
        { "title": "Great experience", "rating": 5, "date": "January 05, 2026", "author": "roserover", "snippet": "Everyone was helpful and efficient…", "employeesWorkedWith": "Thomas D., Tray B." }
    ],
    "searchState": "Florida",
    "searchMake": "Nissan",
    "leadScore": 86,
    "scrapedAt": "2026-06-23T12:00:00.000Z"
}
```

### Monitor mode — only new / changed dealers

Turn on **monitorMode** and the actor remembers every record it has seen (in a named key-value store) and, on later runs, returns **only** records that are **new** or whose **rating / review count / website / staff** changed — each tagged `monitorStatus: "new"` or `"updated"`.

This is **independent of Apify Schedules**: monitor mode handles *what* is new, Schedules handle *when* to run. Combine them — schedule a daily/weekly run with monitor mode on to build a clean fresh-data feed (new dealers, new reviews) straight into your CRM. Use a distinct **monitorStoreName** per saved search to keep histories separate.

### Automate & schedule

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to monitor new dealers and review changes.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger CRM import, Slack alert or email sequence the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/dealerrater-scraper').call({
    states: ['Texas'],
    makes: ['Toyota', 'Honda'],
    maxItems: 200,
    enrichEmails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} dealer leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new dealer leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds new dealers.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the top-rated Toyota dealers in Texas with phone and website" and let it run this scraper.

### More scrapers from scrapesage

Build a complete **automotive & local-business lead stack**:

- **[US Auto Dealer & Repair Shop Leads Scraper](https://apify.com/scrapesage/us-auto-dealer-scraper)** — licensed dealers, repair & body shops from official state DMV registries.
- **[Cars.com Scraper](https://apify.com/scrapesage/cars-com-scraper)** — vehicle listings, prices and dealer info.
- **[Google Maps Scraper](https://apify.com/scrapesage/google-maps-scraper)** — local business listings, phones and reviews.
- **[Yellow Pages Scraper](https://apify.com/scrapesage/yellow-pages-scraper)** — business directory leads.
- **[BBB Scraper](https://apify.com/scrapesage/bbb-scraper)** — Better Business Bureau profiles, ratings and accreditation.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones and socials from any website.
- **[LinkedIn Company Scraper](https://apify.com/scrapesage/linkedin-company-scraper)** — company firmographics and leads.
- **[Trustpilot Scraper](https://apify.com/scrapesage/trustpilot-scraper)** — business reviews and ratings.

### Tips

- **Whole state, any brand**: leave **makes** empty to scan all major brands in a state — dealers selling multiple brands are deduplicated automatically.
- **City filtering**: dealers are listed state-wide and sorted by rating, so raise **maxPagesPerSearch** when you set a **city** so the scan reaches that city's dealers.
- **Proxies**: keep the default U.S. residential proxy for the most reliable results.
- **Cost control**: review samples and salespeople come from the dealer page at no extra cost; email enrichment only runs for dealers that publish a website and is charged only when an email is found.

### FAQ

**How do I scrape car dealers for a specific city?** Set the **city** field plus the **state** (and optionally a **make**). Because DealerRater lists dealers state-wide, increase **maxPagesPerSearch** so the scan reaches your city.

**Can I get the dealer's email?** DealerRater itself doesn't publish emails. Turn on **enrichEmails** and the actor visits the dealer's own public website (the same one a visitor would) and collects publicly listed contact emails.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new dealers or new reviews automatically?** Turn on **monitorMode** and create a [Schedule](https://docs.apify.com/platform/schedules). You'll get only new/changed records each run.

**Is scraping DealerRater legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and DealerRater's terms.

**A field is null — why?** Some dealers genuinely don't publish a website, and many salespeople have few or no reviews. Fields are `null` only when the data isn't on the page, not because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `states` (type: `array`):

US states to scrape dealerships from. Combine with Makes to narrow (state + make). Leave empty if you only paste URLs below.

## `makes` (type: `array`):

Vehicle brands to scrape (e.g. Toyota, Honda, Ford, BMW, Tesla). Each State is crossed with each Make. Leave empty to scan ALL major makes in the chosen states (slower; dealers are deduplicated).

## `city` (type: `string`):

Only keep dealerships in this city (e.g. "Austin"). Dealers are listed state-wide, so increase Max pages per search when filtering by city.

## `searchUrls` (type: `array`):

Paste DealerRater dealer pages (/dealer/...-review-ID/), salesperson pages (/sales/...-review-ID/) or directory pages (/directory/State/Make/). These run in addition to the States/Makes above. Salesperson URLs produce standalone salesperson lead records.

## `minRating` (type: `integer`):

Keep only dealerships with an overall rating at or above this value (0-5).

## `minReviewCount` (type: `integer`):

Keep only dealerships with at least this many reviews.

## `maxReviewsPerDealer` (type: `integer`):

How many recent review samples to embed in each dealer record (title, rating, date, author, snippet). Comes from the same page — no extra cost.

## `enrichEmails` (type: `boolean`):

For dealers that publish their own website, crawl it (home + contact/about, max 3 pages) for contact emails, phones and socials. Billed per email-enrichment event, only when emails are found.

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

Maximum number of records (dealers + salespeople) to return.

## `maxPagesPerSearch` (type: `integer`):

Safety cap on directory result pages (≈30 dealers each) to page through per state+make search.

## `monitorMode` (type: `boolean`):

Remember records seen in previous runs (in a named key-value store) and output only those that are NEW or whose rating / review count / website / staff changed. Each record gets a monitorStatus of "new" or "updated". Works independently of Apify Schedules — schedule the actor to build a fresh-data feed.

## `monitorStoreName` (type: `string`):

Name of the key-value store that holds monitor-mode state. Use a distinct name per saved search to keep histories separate.

## `maxConcurrency` (type: `integer`):

Concurrent page fetches. DealerRater serves clean HTML quickly; 6-10 is a good balance.

## `maxAttemptsPerPage` (type: `integer`):

How many fresh proxy sessions to try before giving up on a page (handles transient proxy errors).

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

Proxy settings. A US RESIDENTIAL proxy is recommended for reliable results — keep the default.

## Actor input object example

```json
{
  "states": [
    "Texas"
  ],
  "makes": [
    "Toyota"
  ],
  "searchUrls": [],
  "maxReviewsPerDealer": 10,
  "enrichEmails": false,
  "maxItems": 100,
  "maxPagesPerSearch": 10,
  "monitorMode": false,
  "monitorStoreName": "dealerrater-monitor",
  "maxConcurrency": 8,
  "maxAttemptsPerPage": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All scraped dealer and salesperson records in the default dataset.

# 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 = {
    "states": [
        "Texas"
    ],
    "makes": [
        "Toyota"
    ],
    "searchUrls": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/dealerrater-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 = {
    "states": ["Texas"],
    "makes": ["Toyota"],
    "searchUrls": [],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/dealerrater-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 '{
  "states": [
    "Texas"
  ],
  "makes": [
    "Toyota"
  ],
  "searchUrls": [],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapesage/dealerrater-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DealerRater Scraper - Car Dealer Reviews & Leads",
        "description": "Scrape DealerRater car dealerships by state, make, city or URL: name, phone, website, full address, star rating, review count, review samples, salespeople and a 0-100 lead score.",
        "version": "0.1",
        "x-build-id": "aUx5OLvOLLK6cwSCa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~dealerrater-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-dealerrater-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/scrapesage~dealerrater-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-dealerrater-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/scrapesage~dealerrater-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-dealerrater-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",
                "properties": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "US states to scrape dealerships from. Combine with Makes to narrow (state + make). Leave empty if you only paste URLs below.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Alabama",
                                "Alaska",
                                "Arizona",
                                "Arkansas",
                                "California",
                                "Colorado",
                                "Connecticut",
                                "Delaware",
                                "District of Columbia",
                                "Florida",
                                "Georgia",
                                "Hawaii",
                                "Idaho",
                                "Illinois",
                                "Indiana",
                                "Iowa",
                                "Kansas",
                                "Kentucky",
                                "Louisiana",
                                "Maine",
                                "Maryland",
                                "Massachusetts",
                                "Michigan",
                                "Minnesota",
                                "Mississippi",
                                "Missouri",
                                "Montana",
                                "Nebraska",
                                "Nevada",
                                "New Hampshire",
                                "New Jersey",
                                "New Mexico",
                                "New York",
                                "North Carolina",
                                "North Dakota",
                                "Ohio",
                                "Oklahoma",
                                "Oregon",
                                "Pennsylvania",
                                "Rhode Island",
                                "South Carolina",
                                "South Dakota",
                                "Tennessee",
                                "Texas",
                                "Utah",
                                "Vermont",
                                "Virginia",
                                "Washington",
                                "West Virginia",
                                "Wisconsin",
                                "Wyoming"
                            ]
                        }
                    },
                    "makes": {
                        "title": "Vehicle makes",
                        "type": "array",
                        "description": "Vehicle brands to scrape (e.g. Toyota, Honda, Ford, BMW, Tesla). Each State is crossed with each Make. Leave empty to scan ALL major makes in the chosen states (slower; dealers are deduplicated).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City filter (optional)",
                        "type": "string",
                        "description": "Only keep dealerships in this city (e.g. \"Austin\"). Dealers are listed state-wide, so increase Max pages per search when filtering by city."
                    },
                    "searchUrls": {
                        "title": "DealerRater URLs (advanced)",
                        "type": "array",
                        "description": "Paste DealerRater dealer pages (/dealer/...-review-ID/), salesperson pages (/sales/...-review-ID/) or directory pages (/directory/State/Make/). These run in addition to the States/Makes above. Salesperson URLs produce standalone salesperson lead records.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minRating": {
                        "title": "Min star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep only dealerships with an overall rating at or above this value (0-5)."
                    },
                    "minReviewCount": {
                        "title": "Min review count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only dealerships with at least this many reviews."
                    },
                    "maxReviewsPerDealer": {
                        "title": "Review samples per dealer",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many recent review samples to embed in each dealer record (title, rating, date, author, snippet). Comes from the same page — no extra cost.",
                        "default": 10
                    },
                    "enrichEmails": {
                        "title": "Enrich with dealer-website emails",
                        "type": "boolean",
                        "description": "For dealers that publish their own website, crawl it (home + contact/about, max 3 pages) for contact emails, phones and socials. Billed per email-enrichment event, only when emails are found.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max records",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records (dealers + salespeople) to return.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap on directory result pages (≈30 dealers each) to page through per state+make search.",
                        "default": 10
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new / changed)",
                        "type": "boolean",
                        "description": "Remember records seen in previous runs (in a named key-value store) and output only those that are NEW or whose rating / review count / website / staff changed. Each record gets a monitorStatus of \"new\" or \"updated\". Works independently of Apify Schedules — schedule the actor to build a fresh-data feed.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Name of the key-value store that holds monitor-mode state. Use a distinct name per saved search to keep histories separate.",
                        "default": "dealerrater-monitor"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Concurrent page fetches. DealerRater serves clean HTML quickly; 6-10 is a good balance.",
                        "default": 8
                    },
                    "maxAttemptsPerPage": {
                        "title": "Max attempts per page",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many fresh proxy sessions to try before giving up on a page (handles transient proxy errors).",
                        "default": 6
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. A US RESIDENTIAL proxy is recommended for reliable results — keep the default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
