# Trustpilot Reviews Scraper — Ratings & Replies (`thenetaji/trustpilot-reviews-scraper`) Actor

Export a company's Trustpilot reviews, several companies in one run. Every review arrives with its rating, text, dates and the company's reply, plus the two fields that separate a genuine complaint from a solicited five star: who invited the review, and how many the writer has ever left.

- **URL**: https://apify.com/thenetaji/trustpilot-reviews-scraper.md
- **Developed by:** [The Netaji](https://apify.com/thenetaji) (community)
- **Categories:** Business, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 72.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.51 / 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.
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?

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

## Trustpilot Reviews Scraper

The Actor downloads a company's Trustpilot reviews as a table: the star rating, the headline, the
review text, the dates, and whatever the company wrote back. Several companies can be listed in one
run, and each is walked in turn, so a whole competitor set arrives in one dataset ready for a
spreadsheet or a sentiment model.

Three columns are the reason to use this rather than copy a review page by hand.
`reviewer_review_count` is the lifetime number of reviews that person has written across all of
Trustpilot, which separates a throwaway account from an established reviewer.
`verification_source` reports `invitation` where the company solicited the review rather than the
reviewer arriving on their own, which is the difference between a wall of genuine praise and a wall
of requested praise. And `reply_percentage`, carried on every row, states what share of its reviews
the company answers; a one-star review reads differently beside a company that answers 2% of its
reviews than beside one that answers 90%.

### Accepted input

`domain` is required and accepts one or more Trustpilot company keys, one per entry. A pasted
Trustpilot company URL is accepted and reduced to the key. `sort` accepts `recency` or `relevance`
and may be omitted. `maxItems` caps how many reviews are saved **for each company in the list** and
defaults to 100; a value of `0` removes the cap and lets each company run to the end of its reviews.

```json
{
  "domain": ["www.amazon.com"],
  "sort": "recency",
  "maxItems": 40
}
```

Keys rarely have to be typed by hand. Every row produced by
[Trustpilot Search Scraper](https://apify.com/thenetaji/trustpilot-search-scraper),
[Trustpilot Category Scraper](https://apify.com/thenetaji/trustpilot-category-scraper) and
[Trustpilot Company List Scraper](https://apify.com/thenetaji/trustpilot-company-list-scraper)
carries the key in its `domain` column, and those strings can be pasted straight in here.

### Response fields

```json
{
  "domain": "www.amazon.com",
  "display_name": "Amazon",
  "profile_url": "https://www.trustpilot.com/review/www.amazon.com",
  "review_id": "6a80e73565b884964e2bc035",
  "page": 1,
  "rating": 1,
  "rating_scale_max": 5,
  "title": "Don't lie !!",
  "text": null,
  "likes": 0,
  "source": "Organic",
  "language": "en",
  "experienced_date": "2026-08-15T00:00:00.000Z",
  "published_date": "2026-08-16T00:24:53.000Z",
  "updated_date": null,
  "has_reply": false,
  "reply_text": null,
  "is_verified": false,
  "verification_source": "invitation",
  "reviewer_name": "Rosemary Hart",
  "reviewer_review_count": 5,
  "reviewer_country": "GB",
  "total_reviews": 45550,
  "total_filtered_reviews": 29953,
  "reply_percentage": 12,
  "average_days_to_reply": 3
}
```

| Field | What it says |
| --- | --- |
| `rating`, `rating_scale_max` | The reviewer's stars, and the top of the scale, which is always 5 here. |
| `title`, `text` | The headline and the body as written. |
| `likes` | How many readers marked the review useful. |
| `source`, `is_verified`, `verification_source` | Whether the reviewer arrived on their own or was invited, and whether Trustpilot verified the purchase. |
| `reviewer_id`, `reviewer_name`, `reviewer_review_count`, `reviewer_country` | Who wrote it, and how many reviews they have written in total. |
| `experienced_date`, `published_date`, `updated_date` | When the experience happened, when the review went up, and when it was last edited. |
| `has_reply`, `reply_text`, `reply_published_date` | Whether the company answered, what it wrote, and when. |
| `language`, `is_pending`, `is_filtered` | The review's language and Trustpilot's own processing flags. |
| `review_id`, `page` | Trustpilot's id for the review, and the page it was read from. |
| `domain`, `display_name`, `profile_url` | The company the review belongs to. |
| `total_reviews`, `total_filtered_reviews`, `reply_percentage`, `average_days_to_reply` | Company context repeated on every row, so a single exported row is readable on its own. |

Three dates are published because they differ routinely. `experienced_date` is when the reviewer says
the experience happened and is the date to use for anything about the business; `published_date` is
when the review went up and is what the `recency` ordering sorts on; `updated_date` is set only where
the reviewer edited the review afterwards.

Fields absent from the upstream response are returned as `null` rather than omitted.

### Questions

**Setting `sort` to Most recent changed nothing. Is the parameter broken?**
No. Trustpilot's own default ordering is already `recency`, so setting `sort` to `recency` returns
the same reviews as omitting `sort` entirely. `relevance` is the value that reorders, and it returns
a different set of reviews rather than the same set in a different order. The parameter looks as
though `recency` were the special case; it is the other way round, and the run log names the ordering
that was actually applied. No other value is accepted, because Trustpilot answers an unknown sort
with a normal response and its default ordering, which would produce plausible, wrongly-ordered data
with nothing to indicate it.

**Why did a run save fewer reviews than `maxItems`?**
Either the company holds fewer reviews than the cap, or the run reached the end of what Trustpilot
pages through. `total_filtered_reviews` on any saved row states the ceiling for that company, and it
is available after a single page has been read. Reviews come twenty to a page, and the run continues
while Trustpilot reports a further page rather than stopping because a page arrived short; the last
page of a long company is usually partial. One company measured 1,498 pages.

**Why do `total_reviews` and `total_filtered_reviews` disagree?**
Both are accurate and they count different things. `total_reviews` is every review the company
holds; `total_filtered_reviews` is the subset matching Trustpilot's default language filter. One
company measured 45,550 against 29,953. Pagination walks the smaller figure, so
`total_filtered_reviews` is the number to size a run against, and the difference between the two is
reviews written in other languages.

**Is `maxItems` shared across the whole run or applied per company?**
Per company. A run given twenty companies is asking for a comparable slice of each, and a single
shared cap would return the first company's reviews and nothing else. A run of twenty companies at
`maxItems` 100 therefore saves up to 2,000 rows.

**Can reviews be filtered by star rating or by date before the run?**
No. Only the company key, the page and the sort order are wired, because Trustpilot answers an
unrecognised filter value with a normal response and its default result set. A filter that had not
been verified against a real comparison would silently do nothing rather than fail, which is worse
than not offering it. Filtering the exported dataset on `rating` or `published_date` reaches the same
result.

**Why is `text` empty on some rows?**
The reviewer left a rating and a title without writing prose, which is common at both ends of the
scale. `has_reply` behaves similarly and deliberately: it is read from the presence of Trustpilot's
reply block rather than from the fields inside it, so it stays accurate where a company replied
without text and `reply_text` is `null`.

**A key returned nothing and the run kept going. Is that a failure?**
No. A key for which Trustpilot serves no company page is reported in the run log and skipped, and the
run continues with the next key, so a stale list of five hundred domains still returns the reviews
for the domains that exist. The usual cause is a key that was constructed rather than copied: a
missing `www.`, or a path that was trimmed. `rac.co.uk/insurance` and `www.rac.co.uk` are two
different companies, and a truncated key returns the other one rather than an error.

**Where is the company's TrustScore?**
Not on this Actor. The review page states the company's review counts and its star distribution but
not the score itself; that value appears on directory rows, and
[Trustpilot Search Scraper](https://apify.com/thenetaji/trustpilot-search-scraper) and
[Trustpilot Category Scraper](https://apify.com/thenetaji/trustpilot-category-scraper) both return
`trust_score`. An average computed from the star distribution is a different number, so none is
published under that name.

**Is a login, a cookie, or a proxy required?**
No. The company key is the only required input.

### Related Actors

[Trustpilot Company Scraper](https://apify.com/thenetaji/trustpilot-company-scraper) returns one row
per company rather than one per review, and is the cheaper choice where the reviews themselves are
not needed. [Trustpilot Search Scraper](https://apify.com/thenetaji/trustpilot-search-scraper)
resolves company names to the keys this Actor takes.

# Actor input Schema

## `domain` (type: `array`):

Trustpilot company keys, one per line — for example www.amazon.com. A pasted Trustpilot company URL works too. Keys are case-insensitive and the `www.` is part of the key, not decoration. Some keys carry a path (`rac.co.uk/insurance`), which is a different company from `rac.co.uk` — pass keys through exactly as you got them. Every row returned by the Search, Category and Company List Actors carries the key in its `domain` field.

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

Trustpilot's own default is recency, so leaving this empty and choosing Most recent give identical results. Relevance is the value that actually reorders.

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

Maximum reviews to save for each company in the list. Set 0 for no limit. Reviews come 20 to a page, so 100 is five pages per company.

## Actor input object example

```json
{
  "domain": [
    "www.amazon.com"
  ],
  "maxItems": 40
}
```

# Actor output Schema

## `dataset` (type: `string`):

All records scraped by this run

# 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 = {
    "domain": [
        "www.amazon.com"
    ],
    "maxItems": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("thenetaji/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 = {
    "domain": ["www.amazon.com"],
    "maxItems": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("thenetaji/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 '{
  "domain": [
    "www.amazon.com"
  ],
  "maxItems": 40
}' |
apify call thenetaji/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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