# Trustpilot Scraper - Business Reviews & Ratings (`themineworks/trustpilot-reviews`) Actor

Scrape Trustpilot business reviews by company domain: reviewer name, star rating, title, text, date and the business reply, plus the overall trust score and total review count. No login. Works in Claude, ChatGPT & any MCP-compatible AI agent.

- **URL**: https://apify.com/themineworks/trustpilot-reviews.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Business, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 reviews

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

## Trustpilot Scraper - Business Reviews & Ratings

Pull **Trustpilot reviews and ratings for any business** straight into a clean dataset. Give it a company domain and the actor returns every review it can reach — reviewer name, star rating, title, full review text, publish date, and the company's official reply — plus the business's overall trust score and total review count. No login, no API key, no headless browser overhead.

Built for market research, competitor monitoring, reputation tracking, voice-of-customer analysis, and feeding review data to AI agents. **Works in Claude, ChatGPT, and any MCP-compatible AI agent** via the Apify MCP server.

### What it does

Trustpilot review pages (`https://www.trustpilot.com/review/<domain>`) are server-rendered with Next.js and embed all review data in a `__NEXT_DATA__` JSON island. Trustpilot fronts every page with an **AWS WAF "Verifying your connection" JavaScript challenge** that blocks datacenter IPs and even plain HTTP requests on residential IPs (the WAF fingerprints the TLS handshake and the challenge JS is never run). To get past it, this actor drives a **real Chromium browser** (via Crawlee's Playwright crawler) routed through **residential proxies**, with consistent human-like browser fingerprints. The browser actually executes the WAF challenge, the page renders, and the actor reads the `__NEXT_DATA__` island from the live DOM, walks the `?page=N` pagination until your limit is reached, and deduplicates by stable review id.

Because beating the WAF requires a browser, **residential proxies are required** (the input is pre-filled with `RESIDENTIAL` + `US`) and the actor runs with 2 GB of memory. It automatically retires the proxy IP and retries on a fresh residential exit if a session never clears the challenge, and it never charges you for a run that returns nothing.

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `companyDomain` | string | yes | `amazon.com` | The business domain to scrape (the slug in `/review/<domain>`). A full URL is accepted and normalised to the bare host. |
| `maxResults` | integer | no | `100` | Maximum number of reviews to return across all pages (1–1000). |
| `starsFilter` | array | no | _(all)_ | Keep only reviews with these star ratings, e.g. `["1","2"]` for negatives only. Empty = all ratings. |
| `proxyConfiguration` | object | no | RESIDENTIAL / US | Proxy settings. **Residential is required** — datacenter IPs are blocked by Trustpilot's WAF. |

#### Example input

```json
{
  "companyDomain": "amazon.com",
  "maxResults": 50,
  "starsFilter": ["1", "2"],
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
````

### Output

One record per review, plus a single `business` aggregate record and a final `summary` record.

#### Sample review record

```json
{
  "business_domain": "amazon.com",
  "reviewer_name": "Jane D.",
  "rating": 5,
  "title": "Fast delivery, great service",
  "text": "Ordered on Monday, arrived Tuesday. Packaging was perfect and support answered in minutes.",
  "review_date": "2026-05-30T09:14:00.000Z",
  "reply_text": "Thanks so much for the kind words, Jane! We're glad it arrived quickly.",
  "review_url": "https://www.trustpilot.com/reviews/abc123def456",
  "review_id": "abc123def456",
  "scraped_at": "2026-06-16T12:00:00.000Z"
}
```

#### Sample business aggregate record

```json
{
  "_type": "business",
  "business_domain": "amazon.com",
  "business_name": "Amazon",
  "overall_rating": 1.8,
  "total_reviews": 17240,
  "trustpilot_url": "https://www.trustpilot.com/review/amazon.com",
  "scraped_at": "2026-06-16T12:00:00.000Z"
}
```

The final `summary` record reports `reviews`, `charged_for`, `pages_scraped`, `free_remaining`, and `total_reviews_on_trustpilot` so you can confirm the run at a glance.

### Pricing

This actor is **Pay-Per-Event**: you are charged **$0.003 per review** delivered (event `review-scraped`). The business aggregate and the summary record are free. The first **25 reviews are free per Apify account (lifetime)** so you can try it risk-free. Runs that return zero reviews — bad domain, no reviews yet, or a blocked page — are never charged.

### FAQ

**Do I really need residential proxies?** Yes. Trustpilot's AWS WAF blocks datacenter IPs (and plain HTTP requests) with a "Verifying your connection" interstitial. The actor runs a real browser on residential IPs to clear it. The input is pre-filled with residential US; leave it on.

**What domain format should I use?** Just the host, e.g. `amazon.com`, `booking.com`, `nike.com`. Pasting a full Trustpilot or company URL also works.

**How many reviews can I get?** Up to 1000 per run via `maxResults`. The actor paginates automatically and stops at your limit or the end of the list.

**Can I get only negative (or only positive) reviews?** Yes — set `starsFilter`, e.g. `["1","2"]` for negatives or `["5"]` for top reviews.

**Will it crash on a bad domain?** No. Unknown domains, empty businesses, and blocked pages exit cleanly with a warning and a summary record, and you are not charged.

**Is it legal?** The actor reads only publicly available, server-rendered review pages — no login or paywall is bypassed. You are responsible for complying with Trustpilot's terms and applicable law in your use of the data.

# Actor input Schema

## `companyDomain` (type: `string`):

The business domain whose Trustpilot reviews you want (e.g. "amazon.com", "booking.com", "nike.com"). This is the slug in https://www.trustpilot.com/review/<domain>. A full URL works too — it is normalised to the bare host.

## `maxResults` (type: `integer`):

Maximum number of reviews to return across all pages.

## `starsFilter` (type: `array`):

Only keep reviews with these star ratings (1-5). Leave empty to keep all ratings. Example: \[1, 2] for negative reviews only.

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

Trustpilot fronts every page with an AWS WAF challenge that blocks datacenter IPs. RESIDENTIAL proxies are REQUIRED for this actor to return data.

## Actor input object example

```json
{
  "companyDomain": "amazon.com",
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "companyDomain": "amazon.com",
    "maxResults": 25,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/trustpilot-reviews").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 = {
    "companyDomain": "amazon.com",
    "maxResults": 25,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/trustpilot-reviews").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 '{
  "companyDomain": "amazon.com",
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call themineworks/trustpilot-reviews --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Scraper - Business Reviews & Ratings",
        "description": "Scrape Trustpilot business reviews by company domain: reviewer name, star rating, title, text, date and the business reply, plus the overall trust score and total review count. No login. Works in Claude, ChatGPT & any MCP-compatible AI agent.",
        "version": "0.2",
        "x-build-id": "vNYOIOxzrvTbypc4g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~trustpilot-reviews/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-trustpilot-reviews",
                "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/themineworks~trustpilot-reviews/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-trustpilot-reviews",
                "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/themineworks~trustpilot-reviews/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-trustpilot-reviews",
                "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": {
                    "companyDomain": {
                        "title": "Company domain",
                        "type": "string",
                        "description": "The business domain whose Trustpilot reviews you want (e.g. \"amazon.com\", \"booking.com\", \"nike.com\"). This is the slug in https://www.trustpilot.com/review/<domain>. A full URL works too — it is normalised to the bare host."
                    },
                    "maxResults": {
                        "title": "Max reviews",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to return across all pages.",
                        "default": 100
                    },
                    "starsFilter": {
                        "title": "Star rating filter (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only keep reviews with these star ratings (1-5). Leave empty to keep all ratings. Example: [1, 2] for negative reviews only.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ]
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Trustpilot fronts every page with an AWS WAF challenge that blocks datacenter IPs. RESIDENTIAL proxies are REQUIRED for this actor to return data.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
