# ConsumerAffairs Scraper | Reviews | Complaints | Ratings (`ahmed_jasarevic/consumeraffairs-reviews-scraper`) Actor

Extract ConsumerAffairs.com company profiles and individual customer reviews — ratings, complaint categories, company replies, and verified status — for review monitoring, complaint analysis, competitive intelligence, and market research.

- **URL**: https://apify.com/ahmed\_jasarevic/consumeraffairs-reviews-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## ConsumerAffairs Reviews Scraper

Extract **ConsumerAffairs.com company profiles** and **individual customer reviews** for review monitoring, complaint analysis, competitive intelligence, and market research in service-heavy industries (home services, insurance, finance, and health). For every review you get the star rating, title, full text, author location, published date, **complaint category**, **company reply**, and **verified status** — plus the company-level aggregate rating and total review count.

ConsumerAffairs is protected by **PerimeterX (HUMAN) bot protection**, so this Actor uses a headless browser (Playwright) through Apify's **residential proxy** to reliably bypass the challenge, with a plain-HTTP **fast mode** that falls back to the browser only when a company gets blocked.

### Main Use Cases

- **Review monitoring** — track a company's ConsumerAffairs reviews and rating changes over time with scheduled runs.
- **Complaint analysis** — extract complaint categories and company replies to spot recurring issues and response quality.
- **Competitive intelligence** — compare review volumes, ratings, and common complaints across competitors in service industries.
- **Reputation management** — build cleaned customer reviews and verified-status data for PR and brand-sentiment teams.
- **Market research** — collect home warranty, insurance, financial-services, and health-industry reviews into a structured dataset.
- **Consumer protection research** — analyze consumer complaints and dispute patterns for policy and advocacy work.

### Build Customer Reviews Datasets Without A Public API

ConsumerAffairs has **no public API** for its review data. This Actor pulls everything a reputation-monitoring or market-research pipeline needs directly from the public review pages — no login, no official API key required — and returns it as clean JSON, CSV, or Excel you can pipe into spreadsheets, dashboards, or downstream analytics.

### How It Works

1. You supply one or more ConsumerAffairs **company URLs or paths** (e.g. `homeowners/american_home_shield` or a full `consumeraffairs.com/insurance/geico.html` URL).
2. In **fast mode** the Actor fetches company pages with plain HTTP (roughly 10x cheaper/faster), automatically falling back to a headless Playwright browser for any company that triggers a PerimeterX challenge.
3. It extracts the **company profile** (aggregate rating, total review count, category) and every **individual review** (rating, text, complaint category, company reply, verified status) up to your configured caps.
4. Results are written to the dataset as two record types — `company` and `review` — ready to download or fetch via the Apify API.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `companyUrls` | string\[] | Yes | — | ConsumerAffairs company page URLs or paths (e.g. `insurance/am_home` or `https://www.consumeraffairs.com/insurance/geico.html`) |
| `maxReviewsPerCompany` | integer | No | 100 | Max reviews to extract per company. `0` = unlimited |
| `maxPagesPerCompany` | integer | No | 50 | Safety cap on paginated pages crawled per company (min 1, max 500) |
| `maxRequestsPerCrawl` | integer | No | 1000 | Global safety cap on page requests for the whole run |
| `scraperMode` | string | No | `fast` | `fast`: plain-HTTP (cheaper/faster) with automatic browser fallback on blocks. `browser`: force headless Chrome for everything |
| `debugSaveHtml` | boolean | No | false | Save raw page HTML to the key-value store for selector debugging. Leave off for normal runs |
| `proxy` | object | No | Apify Proxy (RESIDENTIAL) | Apify proxy config; **residential IPs recommended** to avoid PerimeterX blocking |

### Example Input

```json
{
    "companyUrls": [
        "homeowners/american_home_shield",
        "https://www.consumeraffairs.com/insurance/geico.html"
    ],
    "maxReviewsPerCompany": 100,
    "scraperMode": "fast"
}
```

### Output

Each run produces a dataset with two record types.

**Company profile** (`"type": "company"`):

```json
{
    "type": "company",
    "companyName": "American Home Shield",
    "companySlug": "homeowners/american_home_shield",
    "companyUrl": "https://www.consumeraffairs.com/homeowners/american_home_shield.html",
    "category": "homeowners",
    "overallRating": 3.8,
    "totalReviews": 12450,
    "verified": true
}
```

**Review** (`"type": "review"`):

```json
{
    "type": "review",
    "companyName": "American Home Shield",
    "companySlug": "homeowners/american_home_shield",
    "companyUrl": "https://www.consumeraffairs.com/homeowners/american_home_shield.html",
    "rating": 5,
    "reviewTitle": "Great service",
    "reviewText": "Very satisfied with the coverage...",
    "authorName": "John D.",
    "authorLocation": "Houston, TX",
    "publishedDate": "2026-03-10",
    "complaintCategory": "Customer Service",
    "companyReply": "Thank you for your feedback...",
    "companyReplyDate": "March 12, 2026",
    "verified": true,
    "reviewUrl": "https://www.consumeraffairs.com/homeowners/american_home_shield.html#review-123"
}
```

### Data Fields

| Field | Description |
| --- | --- |
| `rating` | Star rating (1–5) |
| `reviewTitle` | Review headline |
| `reviewText` | Full review text |
| `authorName` | Reviewer name |
| `authorLocation` | Reviewer location (city, state) |
| `publishedDate` | Date the review was published |
| `complaintCategory` | Complaint/topic category (e.g. "Customer Service") |
| `companyReply` | Company response text (if any) |
| `companyReplyDate` | Date of the company reply |
| `verified` | Whether the review carries a verified badge |
| `overallRating` | Company aggregate rating (company profile) |
| `totalReviews` | Company total review count (company profile) |

### Scheduling, Integrations & Automation

This Actor runs serverless and works with every Apify integration:

- **API access** — call it programmatically from any language via the Apify API.
- **Webhooks, Zapier, Make** — pipe new reviews and rating changes into Google Sheets, Slack, or your own alerting pipeline.
- **Scheduling** — set a **daily or weekly recurring run** per company. Review monitoring is a continuous job: consumers leave new reviews constantly, ratings shift, and new complaints appear, so a recurring schedule catches the changes a one-off pull misses (recurring usage also improves Apify's Store recommendation signals).

### Related Actors

For a fuller picture of a company's reputation across review platforms, combine this Actor with other review-data Actors in the same topic cluster:

- [Trustpilot Reviews Scraper — AI Reputation Monitor](https://apify.com/harvestlab/trustpilot-scraper) (harvestlab) — cross-platform company review data for reputation monitoring.
- [Google Maps Reviews Scraper](https://apify.com/compass/Google-Maps-Reviews-Scraper) (compass) — local business reviews and ratings for service businesses.

### FAQ

#### Why use this Actor instead of a ConsumerAffairs API?

ConsumerAffairs does not offer a public API for its review data. This Actor provides the only practical way to get structured company profiles and individual reviews — including complaint categories, company replies, and verified status — at scale, without manual copy-paste or brittle one-off scripts.

#### Does the Actor handle ConsumerAffairs bot protection?

Yes. Fast mode uses plain HTTP and automatically falls back to a headless Playwright browser (with stealth init scripts) for any company that triggers a **PerimeterX (HUMAN)** challenge. Using Apify's **residential proxy** is strongly recommended for reliability; consumer IPs may occasionally still be challenged.

#### What are alternatives to this Actor for review data?

For cross-platform company reputation data, alternatives include Trustpilot and Google Maps review scrapers (see Related Actors). For scraping ConsumerAffairs specifically, the key differentiators of this Actor are the full field set (complaint category, company replies, verified status) in a single dataset, the cheap fast mode, and pay-per-result pricing.

#### How do I monitor a company's reviews and rating changes?

Set `maxReviewsPerCompany` to your desired cap and schedule a recurring run (daily or weekly) for that company's URL. Compare `rating`, `complaintCategory`, and `totalReviews` across runs to detect trends and new complaints.

#### How do I extract complaint categories and company replies?

These come out of the box as the `complaintCategory`, `companyReply`, and `companyReplyDate` fields on every `review` record — no extra configuration needed.

#### Is scraping ConsumerAffairs legal?

Reviews and ratings on ConsumerAffairs are publicly accessible without a login; this Actor only collects publicly visible information. Always review the target site's terms of service and applicable data-protection regulations for your use case.

### For AI Agents & LLM Apps

**Purpose:** Given one or more ConsumerAffairs company URLs, returns a company profile plus every available customer review (rating, text, complaint category, company reply, verified status) as dataset records of type `company` and `review`.

**Minimal working input:**

```json
{ "companyUrls": ["homeowners/american_home_shield"] }
```

**Variant — two extraction modes** (`scraperMode`):

- `fast` (default): plain HTTP, ~10x cheaper/faster, automatic headless-browser fallback only when a company is blocked.
- `browser`: force headless Chrome for every company (more reliable against PerimeterX, more expensive).

**Output fields (dataset):** `type`, `companyName`, `companySlug`, `companyUrl`, `category`, `overallRating`, `totalReviews`, `rating`, `reviewTitle`, `reviewText`, `authorName`, `authorLocation`, `publishedDate`, `complaintCategory`, `companyReply`, `companyReplyDate`, `verified`, `reviewUrl`.

**Behaviors an agent should know:**

- `companyUrls` is the only required field; the act is a no-op without it.
- `maxReviewsPerCompany: 0` means unlimited — set an explicit integer cap to control cost/run time (default 100).
- `scraperMode` is lower-cost by default; choose `browser` only when fast mode returns empty/blocked results.
- `proxy` should use Apify's **residential** group for reliability; datacenter IPs increase PerimeterX blocking.
- `debugSaveHtml: true` adds billed storage (saves every page's HTML) — leave off for normal runs.
- Two record types are emitted (`company` and `review`); group by `companySlug`-style `companyUrl` to join them.

**Billing model:** pay-per-event — $0.005 per `result` (dataset item) plus a small flat start event. Compute is browser-grade in `browser` mode (roughly 1.5–3 CU per 100 review pages) plus residential proxy traffic. Free accounts are capped at 10 reviews per company; paid runs respect the configured `maxReviewsPerCompany`.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by ConsumerAffairs, Inc. It accesses only publicly visible review and company pages on consumeraffairs.com — no login, no CAPTCHA solving, no bypass of paid or private content. Because the output includes reviewer names and locations, users are responsible for their own compliance with ConsumerAffairs' Terms of Service and applicable data-protection law, including GDPR/CCPA where the data concerns EU or California individuals. Reviewer names and locations should not be used for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, GDPR, TCPA). This is not legal advice.

### SEO Keywords

consumeraffairs reviews scraper, consumeraffairs reviews, scrape consumeraffairs reviews, consumeraffairs data, company reviews scraper, review monitoring, reputation management data, complaint analysis, complaint categories, customer reviews dataset, brand monitoring reviews, competitive intelligence reviews, home warranty company reviews, insurance company reviews, financial services reviews, consumer protection research, customer sentiment analysis, verified reviews data, company complaint data, consumeraffairs api

# Actor input Schema

## `companyUrls` (type: `array`):

ConsumerAffairs company page URLs or paths, e.g. "insurance/am\_home" or "https://www.consumeraffairs.com/insurance/geico.html"

## `maxReviewsPerCompany` (type: `integer`):

Maximum number of reviews to extract per company. 0 = unlimited.

## `maxPagesPerCompany` (type: `integer`):

Safety cap on the number of paginated pages crawled per company.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of page requests for the whole run (safety limit).

## `scraperMode` (type: `string`):

FAST: plain-HTTP fetching (~10x cheaper/faster) with automatic headless-browser fallback for companies that get blocked. BROWSER: force headless Chrome for everything.

## `debugSaveHtml` (type: `boolean`):

When enabled, saves the raw HTML of each visited page to the key-value store for selector debugging. Leave off for normal runs.

## `proxy` (type: `object`):

Apify Proxy with Residential IPs is recommended to avoid PerimeterX blocking.

## Actor input object example

```json
{
  "companyUrls": [
    "insurance/am_home",
    "https://www.consumeraffairs.com/insurance/geico.html"
  ],
  "maxReviewsPerCompany": 100,
  "maxPagesPerCompany": 50,
  "maxRequestsPerCrawl": 1000,
  "scraperMode": "fast",
  "debugSaveHtml": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "companyUrls": [
        "insurance/am_home",
        "https://www.consumeraffairs.com/insurance/geico.html"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/consumeraffairs-reviews-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 = {
    "companyUrls": [
        "insurance/am_home",
        "https://www.consumeraffairs.com/insurance/geico.html",
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/consumeraffairs-reviews-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 '{
  "companyUrls": [
    "insurance/am_home",
    "https://www.consumeraffairs.com/insurance/geico.html"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call ahmed_jasarevic/consumeraffairs-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/consumeraffairs-reviews-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/OHHpCzi36k5GJN4Ja/builds/CLqV4bD0gjK9A4vt5/openapi.json