# Trustpilot Reviews Scraper | from $2/1K (`bovi/trustpilot-reviews-scraper`) Actor

Scrape Trustpilot reviews for any business. Full fields: rating, title, text, author, country, verified, company reply + date, date of experience. Filter by stars (multi), language, date range. Derived: star % distribution, parse\_confidence per record. Residential proxy required.

- **URL**: https://apify.com/bovi/trustpilot-reviews-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are 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 Reviews Scraper — Ratings, Replies & Confidence

Extract customer reviews from any Trustpilot business page. Full review
fields including rating, title, text, author, country, verified status,
company reply + reply date, date of experience, and derived rating
distribution per star. Filter by stars (multi-select), language, and date
range. Every record includes `parse_confidence` for structured drift detection.

**Pricing: $2.00 per 1,000 reviews (pay-per-result, no subscription).**

---

### What you get

| Field | Description |
|---|---|
| `business_name` | Company display name on Trustpilot |
| `business_domain` | Domain (e.g. amazon.com) |
| `overall_rating` | Trust score (1.0–5.0) |
| `total_reviews` | Total review count on Trustpilot |
| `star_5_pct` … `star_1_pct` | **Derived**: % reviews at each star level |
| `review_id` | Trustpilot review UUID |
| `url` | Direct link to the review |
| `rating` | Star rating (1–5) |
| `title` | Review headline |
| `text` | Full review body |
| `author` | Reviewer display name |
| `author_country` | ISO 2-letter country code |
| `author_review_count` | Total reviews by this reviewer |
| `author_verified` | Whether reviewer profile is verified |
| `date_published` | ISO 8601 UTC publish datetime |
| `date_experience` | ISO 8601 UTC experience date |
| `verified` | Trustpilot verified purchase flag |
| `verification_level` | `"verified"` / `"not-verified"` / `"invited"` |
| `language` | ISO language code (e.g. `"en"`, `"de"`) |
| `likes` | Helpful vote count |
| `reply` | Company reply text (null if none) |
| `reply_date` | ISO 8601 UTC company reply date |
| `page_number` | Review page this was scraped from |
| `parse_confidence` | Page-level parse quality (0.0–1.0) — our reliability edge |
| `warnings` | Machine-readable warning codes |

---

### Our edge over competitors

| Feature | This actor | Most competitors |
|---|---|---|
| `parse_confidence` per record | ✅ | ❌ |
| Rating distribution (star_N_pct) | ✅ derived | ❌ |
| `reply_date` (ISO) | ✅ | ❌ or partial |
| Multi-star filter (e.g. [1,2]) | ✅ | ❌ (one at a time) |
| `date_experience` (ISO) | ✅ | ❌ or partial |
| PPE pricing (no rental) | ✅ | Mixed |
| Under maintenance? | ✅ active | Several broken |

---

### Quick start

```json
{
  "domains": ["amazon.com"],
  "maxReviews": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

***

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `domains` | string\[] | required | Company domains or full Trustpilot URLs |
| `maxReviews` | integer | 100 | Max reviews per company. 0 = unlimited |
| `stars` | integer\[] | all | Star filter — multi-select, e.g. `[1, 2]` |
| `language` | string | `"all"` | ISO language code or `"all"` |
| `dateRange` | string | `"all"` | `"all"` / `"last30days"` / `"last3months"` / `"last6months"` / `"last12months"` |
| `sort` | string | `"recency"` | `"recency"` or `"relevance"` |
| `proxyConfiguration` | object | — | **Required** — use Apify Residential group |

***

### Use cases

- **Brand reputation monitoring** — daily scheduled runs, filter to 1-2 stars
- **Competitor analysis** — compare `overall_rating`, `star_N_pct`, `reply` rate
- **NLP / sentiment datasets** — verified `text` + `rating` ground truth
- **Market research** — track review velocity and response patterns
- **Lead generation** — identify active reviewers in your niche

***

### Anti-bot reality (honest limits)

Trustpilot uses **AWS WAF** that blocks datacenter and home IP addresses with
a JavaScript challenge page (HTTP 403). This is IP-reputation-based, not
TLS fingerprinting — residential proxies pass through cleanly.

**A proxy is required.** Configure `proxyConfiguration` with Apify's
Residential proxy group. The buyer (you) pays for proxy compute — this keeps
the per-review price low.

Without a proxy you will see: `Trustpilot blocked request: http_403` in logs.

***

### Performance

| Reviews | Estimated time |
|---|---|
| 100 | ~30–60 seconds |
| 500 | ~3–5 minutes |
| 5,000 | ~25–35 minutes |
| All (unlimited) | Depends on company size |

Trustpilot shows 20 reviews per page. The actor paginates via the Next.js
`/_next/data/` JSON endpoint (no HTML parsing after page 1) at ~20 req/min
to stay under WAF rate limits.

***

### Pricing

**$2.00 per 1,000 reviews** (PPE, pay-per-result).

Apify's free plan includes $5 credit = ~2,500 reviews at no cost.

Proxy cost (Apify Residential): ~$3.50/GB. A typical review page is ~50KB,
so 1,000 reviews (50 pages) ≈ 2.5MB ≈ under $0.01 in proxy costs.

***

### Integrations

Built for brand and CX teams tracking reputation, mining customer sentiment, and benchmarking competitors on Trustpilot — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Legal

This actor accesses publicly visible review data on Trustpilot — the same
data any browser user can see without logging in. Users are responsible for
compliance with Trustpilot's Terms of Service, GDPR, and CCPA as applicable.
Do not republish review content as your own. This actor is not affiliated
with or endorsed by Trustpilot A/S.

# Actor input Schema

## `domains` (type: `array`):

List of company domains (e.g. amazon.com) or full Trustpilot review URLs (https://www.trustpilot.com/review/amazon.com). One or more.

## `maxReviews` (type: `integer`):

Maximum number of reviews to scrape per company. Set to 0 for all reviews (may take several minutes for large companies).

## `stars` (type: `array`):

Filter by star rating. Select one or more values. Leave empty to get all ratings.

## `language` (type: `string`):

ISO language code to filter reviews (e.g. en, de, fr, es). Leave blank or use 'all' for all languages.

## `dateRange` (type: `string`):

Only return reviews published within this period.

## `sort` (type: `string`):

How to sort reviews. 'recency' returns newest first (recommended for monitoring).

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

REQUIRED: Trustpilot blocks datacenter IPs with AWS WAF. Use Apify Residential proxy group. Without proxy, runs will return 403 errors.

## Actor input object example

```json
{
  "domains": [
    "amazon.com",
    "stripe.com"
  ],
  "maxReviews": 500,
  "stars": [
    "1",
    "2"
  ],
  "language": "en",
  "dateRange": "all",
  "sort": "recency",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing Trustpilot Reviews Scraper records (business\_name, business\_domain, overall\_rating, total\_reviews, review\_id, rating, title, author, author\_country, verified, date\_published, parse\_confidence).

# 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 = {
    "domains": [
        "amazon.com"
    ],
    "maxReviews": 100,
    "language": "all",
    "dateRange": "all",
    "sort": "recency",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/trustpilot-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 = {
    "domains": ["amazon.com"],
    "maxReviews": 100,
    "language": "all",
    "dateRange": "all",
    "sort": "recency",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/trustpilot-reviews-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 '{
  "domains": [
    "amazon.com"
  ],
  "maxReviews": 100,
  "language": "all",
  "dateRange": "all",
  "sort": "recency",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper | from $2/1K",
        "description": "Scrape Trustpilot reviews for any business. Full fields: rating, title, text, author, country, verified, company reply + date, date of experience. Filter by stars (multi), language, date range. Derived: star % distribution, parse_confidence per record. Residential proxy required.",
        "version": "0.1",
        "x-build-id": "bdTfC8AVzoUY6soye"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-trustpilot-reviews-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/bovi~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-trustpilot-reviews-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/bovi~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-trustpilot-reviews-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",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Company domains or Trustpilot URLs",
                        "type": "array",
                        "description": "List of company domains (e.g. amazon.com) or full Trustpilot review URLs (https://www.trustpilot.com/review/amazon.com). One or more.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per company. Set to 0 for all reviews (may take several minutes for large companies).",
                        "default": 100
                    },
                    "stars": {
                        "title": "Star rating filter",
                        "type": "array",
                        "description": "Filter by star rating. Select one or more values. Leave empty to get all ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ]
                        }
                    },
                    "language": {
                        "title": "Language filter",
                        "type": "string",
                        "description": "ISO language code to filter reviews (e.g. en, de, fr, es). Leave blank or use 'all' for all languages.",
                        "default": "all"
                    },
                    "dateRange": {
                        "title": "Date range filter",
                        "enum": [
                            "all",
                            "last30days",
                            "last3months",
                            "last6months",
                            "last12months"
                        ],
                        "type": "string",
                        "description": "Only return reviews published within this period.",
                        "default": "all"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort reviews. 'recency' returns newest first (recommended for monitoring).",
                        "default": "recency"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "REQUIRED: Trustpilot blocks datacenter IPs with AWS WAF. Use Apify Residential proxy group. Without proxy, runs will return 403 errors."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
