# Trustpilot Reviews Scraper (`junipr/trustpilot-reviews-scraper`) Actor

Scrape Trustpilot reviews: rating, title, body, date, verification, business reply. Business summary with TrustScore and rating distribution. Filter by stars, sort by date/rating. Pagination for large volumes.

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

## Pricing

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

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 Reviews Scraper

Scrape customer reviews, star ratings, reviewer details, business replies, and overall rating summaries from [Trustpilot](https://www.trustpilot.com) for any business. Works with any public Trustpilot business profile — no API key or Trustpilot account required.

### What This Actor Does

The Trustpilot Reviews Scraper crawls Trustpilot review pages and extracts structured review data for one or more businesses in a single run. Each review record includes the reviewer's name, star rating (1–5), review title, full review text, the date it was posted, the date of the customer's experience, whether the review is verified, and the business owner's reply if one was written.

You can filter reviews by star rating (e.g., scrape only 1-star or 5-star reviews), sort by recency or Trustpilot relevance, and set a maximum number of reviews per business. The actor also optionally outputs a business summary record per company containing the overall TrustScore, total review count, and star rating distribution breakdown.

### Input Configuration

| Parameter | Type | Default | Description |
|---|---|---|---|
| `businessUrls` | array | Amazon | List of Trustpilot business profile URLs to scrape |
| `maxReviews` | integer | 100 | Maximum reviews to collect per business (1–10,000) |
| `sortBy` | string | recency | Sort order: `recency` or `relevance` |
| `filterByStars` | string | all | Filter to specific star rating: `all`, `1`, `2`, `3`, `4`, or `5` |
| `includeBusinessInfo` | boolean | true | Output a summary record with overall rating, review count, and distribution |
| `maxConcurrency` | integer | 5 | Concurrent requests (1–10) |
| `requestTimeout` | integer | 30000 | Request timeout in milliseconds |

#### Example Input

```json
{
  "businessUrls": [
    { "url": "https://www.trustpilot.com/review/amazon.com", "label": "amazon" },
    { "url": "https://www.trustpilot.com/review/airbnb.com", "label": "airbnb" }
  ],
  "maxReviews": 500,
  "sortBy": "recency",
  "filterByStars": "all",
  "includeBusinessInfo": true
}
````

### Output Data

The actor outputs two types of records to the Apify dataset:

#### Review Record

```json
{
  "recordType": "review",
  "businessName": "Amazon",
  "businessUrl": "https://www.trustpilot.com/review/amazon.com",
  "reviewerName": "Jane Smith",
  "reviewTitle": "Fast delivery and great customer service",
  "reviewText": "Ordered on Monday and it arrived Wednesday. Product was exactly as described. Would buy again.",
  "rating": 5,
  "datePosted": "2024-11-15T00:00:00.000Z",
  "dateOfExperience": "2024-11-13T00:00:00.000Z",
  "isVerified": true,
  "replyText": null,
  "language": "en",
  "reviewUrl": "https://www.trustpilot.com/reviews/abc123def456"
}
```

#### Business Summary Record

```json
{
  "recordType": "businessSummary",
  "businessName": "Amazon",
  "businessUrl": "https://www.trustpilot.com/review/amazon.com",
  "overallRating": 2.6,
  "totalReviews": 41823,
  "trustScore": 2.6,
  "ratingDistribution": {
    "5": 15200,
    "4": 3100,
    "3": 2400,
    "2": 3600,
    "1": 17523
  }
}
```

### Use Cases

**Brand monitoring:** Track what customers are saying about your business on Trustpilot over time. Set up scheduled runs to collect fresh reviews daily or weekly and pipe results into your analytics pipeline or CRM.

**Competitive intelligence:** Scrape reviews for competing businesses to understand their customer satisfaction patterns, common complaints, and strengths. Compare your star distribution against competitors.

**Sentiment analysis:** Feed review text into LLMs or sentiment analysis models to identify positive and negative themes. Filter to 1-star reviews to surface the most critical pain points.

**Lead generation and sales research:** Identify businesses with poor Trustpilot ratings — potential customers for your product or service. Filter by industry and star rating to build targeted prospect lists.

**Review management:** Monitor for new negative reviews that require a business owner response. Automate alerts when 1-star or 2-star reviews are posted.

**Academic and market research:** Collect large datasets of consumer reviews for research purposes. Filter by language, date range, or star rating to build focused research datasets.

### How It Works

The actor uses [CheerioCrawler](https://crawlee.dev/docs/guides/cheerio-crawler) from the Crawlee library to fetch and parse Trustpilot review pages. Since Trustpilot renders review content server-side, no headless browser or JavaScript execution is required, making the scraper fast and resource-efficient.

For each business URL, the actor:

1. Fetches the first page of reviews with the specified sort order and star filter
2. Extracts all review records from the page HTML
3. Pushes records to the dataset and charges a PPE billing event per review
4. Follows pagination links to collect additional reviews until `maxReviews` is reached
5. Optionally extracts business summary data (overall rating, review count, distribution) from the first page

Requests are routed through Apify Proxy to avoid rate limiting. Session pooling and cookie persistence help maintain stable connections across paginated requests.

### Pricing

This actor uses Pay-Per-Event (PPE) billing. You are charged **$0.0005 per review scraped**. Business summary records are not billed separately. A free tier is included so you can test the actor before committing to paid usage.

Pricing includes all platform compute costs — no hidden fees.

### FAQ

#### What Trustpilot pages does this scraper support?

Any public Trustpilot business review page. The URL format is `https://www.trustpilot.com/review/{domain}`. The actor works with any business that has a public Trustpilot profile.

#### Does this require a Trustpilot account or API key?

No. Trustpilot review pages are publicly accessible without authentication. No account or API key is needed.

#### How many reviews can I scrape per run?

Up to 10,000 reviews per business per run. For larger datasets, run the actor multiple times with different filters (e.g., by star rating) and merge the results.

#### Will this work on private or invitation-only business profiles?

No. The actor can only access publicly visible Trustpilot review pages. Profiles that require login or have been set to private are not accessible.

#### Can I scrape reviews in languages other than English?

Yes. The actor scrapes reviews in any language. The `language` field in each review record contains the ISO 639-1 language code (e.g., `en`, `de`, `fr`, `es`). Trustpilot shows reviews in the language they were written.

#### How does star rating filtering work?

Setting `filterByStars` to `"1"` through `"5"` passes the `stars` query parameter to Trustpilot's review pages, so only reviews with that exact star count are returned. Set to `"all"` to collect reviews of any rating.

#### Why might some fields be null in the output?

Some Trustpilot review pages use varying HTML structures depending on business account type, language, and Trustpilot A/B testing. Fields like `replyText`, `dateOfExperience`, and `reviewUrl` may be null when the corresponding data is not present or could not be extracted from the page structure.

### Related Actors

- [Reddit Scraper](https://apify.com/junipr/reddit-scraper) — Scrape posts, comments, and subreddit data from Reddit
- [Hacker News Scraper](https://apify.com/junipr/hacker-news-scraper) — Scrape stories, comments, and users from Hacker News
- [Yellow Pages Scraper](https://apify.com/junipr/yellow-pages-scraper) — Scrape business listings from Yellow Pages

# Actor input Schema

## `businessUrls` (type: `array`):

List of Trustpilot business profile URLs to scrape reviews from. Each entry should have a 'url' field with the full Trustpilot URL (e.g. https://www.trustpilot.com/review/amazon.com) and an optional 'label' for identification in output.

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

Maximum number of reviews to scrape per business. Higher values take longer but return more data. The actor will stop when this limit is reached.

## `sortBy` (type: `string`):

How to sort reviews when scraping. 'recency' returns the most recent reviews first. 'relevance' returns reviews Trustpilot considers most helpful/relevant.

## `filterByStars` (type: `string`):

Only scrape reviews with a specific star rating. Use 'all' to collect reviews of any rating. Use '1' through '5' to filter to a specific star count.

## `includeBusinessInfo` (type: `boolean`):

When enabled, scrapes and outputs a summary record per business including overall rating, total reviews count, trust score, and star rating distribution breakdown.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent page requests. Higher values are faster but increase the chance of being rate-limited by Trustpilot. Recommended: 3-5.

## `requestTimeout` (type: `integer`):

Timeout in milliseconds for each HTTP request. Increase this if you encounter frequent timeout errors on slow connections.

## Actor input object example

```json
{
  "businessUrls": [
    {
      "url": "https://www.trustpilot.com/review/amazon.com",
      "label": "amazon"
    }
  ],
  "maxReviews": 100,
  "sortBy": "recency",
  "filterByStars": "all",
  "includeBusinessInfo": true,
  "maxConcurrency": 5,
  "requestTimeout": 30000
}
```

# Actor output Schema

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

Individual review records and business summary records scraped from Trustpilot. Each review includes reviewer name, rating, text, date, and business reply if present.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("junipr/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 '{}' |
apify call junipr/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper",
        "description": "Scrape Trustpilot reviews: rating, title, body, date, verification, business reply. Business summary with TrustScore and rating distribution. Filter by stars, sort by date/rating. Pagination for large volumes.",
        "version": "1.0",
        "x-build-id": "opoCOxjCgPdfArjH3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-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/junipr~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-junipr-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/junipr~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-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",
                "properties": {
                    "businessUrls": {
                        "title": "Business URLs",
                        "type": "array",
                        "description": "List of Trustpilot business profile URLs to scrape reviews from. Each entry should have a 'url' field with the full Trustpilot URL (e.g. https://www.trustpilot.com/review/amazon.com) and an optional 'label' for identification in output.",
                        "items": {
                            "type": "object"
                        },
                        "default": [
                            {
                                "url": "https://www.trustpilot.com/review/amazon.com",
                                "label": "amazon"
                            }
                        ]
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Business",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per business. Higher values take longer but return more data. The actor will stop when this limit is reached.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort reviews when scraping. 'recency' returns the most recent reviews first. 'relevance' returns reviews Trustpilot considers most helpful/relevant.",
                        "default": "recency"
                    },
                    "filterByStars": {
                        "title": "Filter By Stars",
                        "enum": [
                            "all",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only scrape reviews with a specific star rating. Use 'all' to collect reviews of any rating. Use '1' through '5' to filter to a specific star count.",
                        "default": "all"
                    },
                    "includeBusinessInfo": {
                        "title": "Include Business Info",
                        "type": "boolean",
                        "description": "When enabled, scrapes and outputs a summary record per business including overall rating, total reviews count, trust score, and star rating distribution breakdown.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of concurrent page requests. Higher values are faster but increase the chance of being rate-limited by Trustpilot. Recommended: 3-5.",
                        "default": 5
                    },
                    "requestTimeout": {
                        "title": "Request Timeout (ms)",
                        "minimum": 5000,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Timeout in milliseconds for each HTTP request. Increase this if you encounter frequent timeout errors on slow connections.",
                        "default": 30000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
