# Trustpilot Reviews Scraper API — No 200 Cap, from $0.50 per 1K (`sherwood/trustpilot-reviews-scraper`) Actor

Scrape Trustpilot reviews for any company in bulk: rating, title, text, dates, language, reviewer country, verification, company reply, company score. Goes past the 200-review listing cap with filter and keyword splitting. Reviewer names are never collected. From $0.50 per 1,000 reviews.

- **URL**: https://apify.com/sherwood/trustpilot-reviews-scraper.md
- **Developed by:** [Sherwood](https://apify.com/sherwood) (community)
- **Categories:** Lead generation, E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 review scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

## Trustpilot Reviews Scraper API — No 200 Cap, from $0.50 per 1K

Get the Trustpilot reviews of any company as clean JSON — rating, title, text, dates, language, reviewer country,
verification, company reply, company score — for **$0.50 per 1,000 reviews on the free plan**, from $0.50 per 1,000 on paid plans (see Pricing). Give it
domains, website URLs or Trustpilot URLs from any country; it returns one dataset item per review, in the field names of
the most used Trustpilot scraper, so existing workflows keep working. It reads **past Trustpilot's 200-review listing
cap** by splitting the listing by language, rating, date window, verification, replies, sort order and keywords, then
deduplicating. **Reviewer names are never collected**: no name, avatar or profile link, and the first-name greeting at
the top of a company reply is masked — a GDPR-friendly dataset by design.

### What you get

One item per review (`status: "ok"`). A company that produced no review gets one item with `status` `notfound`,
`empty` or `error` and an `error` message, review fields `null`, and is never charged.

```json
{
  "status": "ok",
  "reviewId": "6af021ddae5d6ca6daa8562c",
  "reviewUrl": "https://www.trustpilot.com/reviews/6af021ddae5d6ca6daa8562c",
  "title": "Easy",
  "text": "Easy! Save so far ! ",
  "rating": 5,
  "publishedDate": "2026-11-08T09:16:45.000Z",
  "experienceDate": "2026-11-08T00:00:00.000Z",
  "updatedDate": null,
  "language": "en",
  "likes": 0,
  "verificationLevel": "invited",
  "isVerified": true,
  "source": "BusinessGeneratedLink",
  "authorReviewCount": 3,
  "country": "FR",
  "replyMessage": null,
  "replyPublishedDate": null,
  "replyUpdatedDate": null,
  "companyName": "Wise",
  "companyDomain": "wise.com",
  "companyTrustScore": 4.3,
  "companyStars": 4.5,
  "companyTotalReviews": 305357,
  "companyCategories": [
    "Financial Institution",
    "Money Transfer Service"
  ],
  "companyUrl": "https://www.trustpilot.com/review/wise.com",
  "error": null,
  "input": "wise.com"
}
```

| Field | Meaning |
|---|---|
| `reviewId`, `reviewUrl` | Trustpilot's review id and public page |
| `title`, `text`, `rating` | Review title, body and stars (1–5) |
| `publishedDate`, `experienceDate`, `updatedDate` | ISO 8601, UTC |
| `language` | ISO code of the review text |
| `likes` | "Useful" votes |
| `verificationLevel`, `isVerified`, `source` | `invited`, `verified`, `not-verified`; how the review was collected (`Organic`, `BasicLink`, `BusinessGeneratedLink`, …) |
| `authorReviewCount`, `country` | Number of reviews written by the reviewer and their country — no identity |
| `replyMessage`, `replyPublishedDate`, `replyUpdatedDate` | The company's public reply, greeting without the reviewer's first name |
| `companyName`, `companyDomain`, `companyTrustScore`, `companyStars`, `companyTotalReviews`, `companyCategories`, `companyUrl` | Company profile at scrape time (`includeCompanyInfo`) |
| `status`, `error`, `input` | `ok` / `notfound` / `empty` / `error`, the error message, the input entry this item answers |

### Use cases

- **Competitor watch**: the 1 and 2 star reviews of a competitor, then [Review Analyzer API](https://apify.com/sherwood/review-analyzer) for the themes and the complaints they never answered.
- **Reputation monitoring**: a weekly run with `publishedAfter` set to the latest `publishedDate` you saved — one or two pages, whatever the company's size.
- **Market research**: the reviews of three competitors in one run, each item carrying its company's TrustScore and review count.
- **Lead qualification**: a company's rating distribution and reply behaviour before you call them.
- **Datasets for AI**: thousands of real reviews per language and rating, without personal data of reviewers.

### Input

Every field is optional. With no input, the Actor reads 20 reviews of pipedrive.com so you can see the output shape.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `companyUrls` | array of strings | `["pipedrive.com"]` | Domains (`wise.com`), website URLs, or Trustpilot URLs from any country (`https://fr.trustpilot.com/review/pipedrive.com`). Aliases: `companyUrl`, `domains`, `startUrls`, `urls`; a string with commas or new lines is split. The example is dropped as soon as you give another company. |
| `maxReviewsPerCompany` | integer | 20 | Reviews kept per company, newest first. Up to 200 is one fast listing (seconds). Above 200, or `0` for every review the public site exposes, the Actor goes through the deep path (see Limits): count 3 to 7 minutes and about 350 requests per 1,000 reviews for a company with thousands of reviews. |
| `stars` | array | all | Keep only these ratings, e.g. `["1", "2"]`. |
| `languages` | array | all | ISO codes to keep, e.g. `["en", "fr"]`. |
| `publishedAfter` | string | — | ISO date; only reviews published strictly after it. Pagination stops at the boundary, so an incremental sync is cheap whatever the company's size. |
| `date` | string | all time | Trustpilot's own window: `last30days`, `last3months`, `last6months`, `last12months`. |
| `sort` | string | `recency` | `recency` or `relevance` for the first listing. |
| `verifiedOnly` | boolean | false | Only reviews Trustpilot marks as verified. |
| `withReplies` | boolean | false | Only reviews the company replied to. |
| `includeCompanyInfo` | boolean | true | Company fields on every review; off keeps only `companyDomain`. |

```json
{
  "companyUrls": ["wise.com", "https://fr.trustpilot.com/review/pipedrive.com", "www.backmarket.fr"],
  "maxReviewsPerCompany": 500,
  "stars": ["1", "2"],
  "publishedAfter": "2026-01-01"
}
```

### Pricing

- **Review scraped** — per review saved. The price depends on your Apify plan: $0.0005 on the free plan ($0.50 per 1,000), $0.0008 on Starter ($0.80 per 1,000), $0.0006 on Scale ($0.60 per 1,000), $0.0005 on Business and above ($0.50 per 1,000) — the store page shows yours.
- **Actor start** — $0.00005 per run (one per GB of memory, minimum one).
- Companies not on Trustpilot, companies without matching reviews, failed companies and duplicates: free.
- Set `maxTotalChargeUsd` on the run to cap it; the Actor stops cleanly at the limit and says what remains.

Speed: about 1,000 reviews in 40 seconds, 20 companies × 100 reviews in under a minute (measured 2026-11-08).

### Via API, Python, n8n, Make or MCP

```bash
curl -X POST "https://api.apify.com/v2/acts/sherwood~trustpilot-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companyUrls": ["wise.com"], "maxReviewsPerCompany": 200}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("sherwood/trustpilot-reviews-scraper").call(run_input={"companyUrls": ["wise.com"], "maxReviewsPerCompany": 200})
reviews = [item for item in client.dataset(run["defaultDatasetId"]).iterate_items() if item["status"] == "ok"]
```

- **n8n / Make**: Apify node → Run an Actor → `sherwood/trustpilot-reviews-scraper`, JSON input as above, then "Get dataset items". Filter on `status == "ok"`.
- **AI agents (MCP)**: with the Apify MCP server, ask for "Trustpilot reviews of wise.com, last 30 days, 1 and 2 stars"; the schema needs nothing but a company. This Actor accepts agentic payments.
- **Review analysis**: on the Integrations tab, add [Review Analyzer API](https://apify.com/sherwood/review-analyzer) after this Actor ([video: Actor-to-Actor integration](https://www.youtube.com/watch?v=zExnYbvFoBM)), or pass this run's `defaultDatasetId` as its `datasetId`.

### Use it from an AI coding agent

Install the task skill for Claude Code, Codex, Cursor, Gemini CLI or any agent that reads the Agent Skills format:

```bash
npx skills add maxouf/sherwood-skills --skill trustpilot-scraper
```

The skill compares this Actor with the other tools for the task, estimates the cost before running, caps the spend and hands back the result as a file. The pipeline skill `apify-competitor-watch` chains it with the other Actors of the use case. Source: [github.com/maxouf/sherwood-skills](https://github.com/maxouf/sherwood-skills).

### Run it on a schedule

Reviews arrive every day. Create a [schedule](https://docs.apify.com/platform/schedules) on this Actor, or on a saved task holding your companies — Apify's one-minute video shows how: [Schedule your Actor](https://www.youtube.com/watch?v=1jI7WcVQmwM). Pass the latest `publishedDate` of the previous run as `publishedAfter`: only newer reviews come back and are charged.

### Limits

- **200 reviews per listing, then the deep path.** Trustpilot's public site shows at most 200 reviews per listing. Up to 200 the Actor reads one listing in seconds. Above 200 (or `maxReviewsPerCompany: 0`) it splits the listing by language, rating, the four date windows of the last 12 months, verified, with-reply, sort order, then by keywords taken from the reviews already read, and deduplicates: 92 to 97 % of all reviews on companies with 1,700 to 3,500 reviews (measured 2026-11-08), in 3 to 7 minutes and about 350 requests per 1,000 reviews. On companies with hundreds of thousands of reviews it returns the most recent few thousand plus everything of the last 12 months. Latest reviews, filtered reviews and incremental syncs lose nothing.
- **Anti-bot.** Trustpilot sits behind an AWS WAF JavaScript challenge. The Actor solves it with a headless browser once every five minutes and reads pages in plain HTTP from the Apify platform's own IP, which it shares with other Actors; when that IP is throttled it switches to a residential IP for the request. A changed challenge can make a run slower or fail: companies then come back with `status: "error"` and are not charged.
- **No reviewer identity.** Names, avatars and profile links are not read; the first-name greeting of company replies is masked (en, fr, de, es, it, nl). A company reply may still mention details the company chose to publish.
- **Not included.** Consumer profiles, product reviews, location pages, Trustpilot keyword search, pending or hidden reviews.

### Related Actors

- [Review Analyzer API](https://apify.com/sherwood/review-analyzer) — sentiment, themes, serious complaints and unanswered reviews per company, straight from this Actor's dataset (`datasetId`); it reads these field names as they are.
- [Google Maps Scraper API](https://apify.com/sherwood/google-maps-scraper) — places, phones, websites and ratings for local businesses, with AI lead verdicts.
- [Google Ads Transparency Scraper API](https://apify.com/sherwood/google-ads-transparency-scraper) — the ads a competitor runs, next to what its customers say here.
- [Trade Show People Finder](https://apify.com/sherwood/trade-show-people-finder) — exhibitors and attendees of a trade show, with evidence.

### FAQ

**How do I scrape Trustpilot reviews without an API key?**
Give a domain, a website URL or a Trustpilot page URL and the Actor returns every review as a dataset item: stars, title, text, dates, language, reviewer country, verification, company reply and the company's TrustScore. No API key, no login, no cookie.

**Why do I get fewer reviews than the company's total?**
See Limits: 200 per listing, then the deep path with keywords. Set `languages` or `stars` to focus the budget on what you need, or run incremental syncs with `publishedAfter`.

**Does it work with fr.trustpilot.com, uk.trustpilot.com and the other regional domains?**
Yes: regional URLs are accepted and redirected to the canonical profile; reviews in every language come back unless `languages` says otherwise.

**Are reviewer names included?**
No, by design. You get the reviewer's country, number of reviews and verification status, which is what analysis needs, without personal data to protect.

**Is scraping Trustpilot allowed?**
The Actor reads public pages only, without login, and keeps no personal data of reviewers. Check Trustpilot's terms and your local law for your use case.

**What does a run of 10,000 reviews cost?**
$5 on the free plan ($0.50 per 1,000) plus $0.00005 of Actor start; nothing for companies that fail. Count 20 to 60 minutes if those 10,000 reviews mean going deep on a few large companies, a few minutes if they are the latest reviews of many companies.

# Actor input Schema

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

One entry per company: a domain ("pipedrive.com"), a website URL, or a Trustpilot page URL from any country ("https://fr.trustpilot.com/review/pipedrive.com"). Aliases: companyUrl, domains, startUrls, urls (a string with commas or new lines is split).

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

Reviews kept per company, newest first. Up to 200 is one fast listing (a few seconds). Above 200, or 0 for every review the public site exposes, the Actor splits the listing by language, rating, date window, verification, replies, sort order and keywords, then deduplicates: count 3 to 7 minutes and about 350 requests per 1,000 reviews for a company with thousands of reviews. Default 20.

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

Keep only these ratings. Empty = all ratings.

## `languages` (type: `array`):

ISO codes of review languages to keep ("en", "fr", "de"). Empty = all languages.

## `publishedAfter` (type: `string`):

ISO date or datetime ("2026-01-01" or "2026-01-01T00:00:00Z"). Only reviews published strictly after it are kept; pagination stops at the boundary, which makes incremental syncs cheap. Example: 2026-01-01

## `date` (type: `string`):

Trustpilot's own date filter. Default: all time.

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

Order of the first listing. Default: most recent first.

## `verifiedOnly` (type: `boolean`):

Keep only reviews Trustpilot marks as verified (invitation or proof of purchase).

## `withReplies` (type: `boolean`):

Keep only reviews the company replied to.

## `includeCompanyInfo` (type: `boolean`):

Adds companyName, companyTrustScore, companyStars, companyTotalReviews, companyCategories and companyUrl to each review. Off: only companyDomain.

## Actor input object example

```json
{
  "companyUrls": [
    "pipedrive.com"
  ],
  "maxReviewsPerCompany": 20,
  "stars": [],
  "languages": [],
  "publishedAfter": "2026-01-01",
  "date": "",
  "sort": "recency",
  "verifiedOnly": false,
  "withReplies": false,
  "includeCompanyInfo": true
}
```

# Actor output Schema

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

One item per review (status ok), plus one item per company that produced no review (status notfound, empty or error).

# 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": [
        "pipedrive.com"
    ],
    "maxReviewsPerCompany": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("sherwood/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 = {
    "companyUrls": ["pipedrive.com"],
    "maxReviewsPerCompany": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("sherwood/trustpilot-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": [
    "pipedrive.com"
  ],
  "maxReviewsPerCompany": 20
}' |
apify call sherwood/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sherwood/trustpilot-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/L8XEjg2xyCHFC2vff/builds/DLkf2E7hYPJC9MgCi/openapi.json
