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

Scrape Trustpilot reviews for any company. Get review text, star ratings, author names, dates, and company responses. Filter by rating and sort by newest or most relevant.

- **URL**: https://apify.com/ef12/trustpilot-reviews-scraper.md
- **Developed by:** [Daniel Wilson](https://apify.com/ef12) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### What does Trustpilot Reviews Scraper do?

The **Trustpilot Reviews Scraper** extracts customer reviews from any company page on [Trustpilot.com](https://www.trustpilot.com). It captures **author**, **rating**, **title**, **review body**, **date**, **company response**, **verified status**, and the **direct review URL** — all as structured JSON data that you can export, analyze, or feed into dashboards and AI pipelines.

Built on the Apify platform, this Actor runs reliably in the cloud with automatic proxy rotation, scheduling, dataset exports, and API access — no infrastructure to manage, no captchas to solve.

### Why use Trustpilot Reviews Scraper?

Customer reviews are one of the richest sources of product intelligence available online, but copying them by hand is slow and impractical at scale. Use this scraper to:

- **Benchmark competitors** — Monitor how customers rate competing products and services over time.
- **Train sentiment models** — Build labeled datasets of real customer opinions for NLP and classification tasks.
- **Validate product decisions** — Understand what users actually praise or complain about before launching features.
- **Populate business dashboards** — Ingest review data into BI tools for real-time brand health tracking.
- **Build review aggregators** — Pull reviews into your own application or marketplace.

### Use Cases

#### Competitive Intelligence

Track how your competitors are reviewed over weeks or months. Set a recurring schedule in Apify Console to scrape the same company pages daily and watch rating trends, response patterns, and sentiment shifts.

#### Market Research

Analyze hundreds of reviews across multiple companies in a vertical. Filter by minimum rating to focus on positive or negative sentiment. Export to CSV or JSON for spreadsheet analysis or downstream processing.

#### Customer Feedback Analysis

Extract the full text of reviews and feed them into an LLM or NLP pipeline for topic modeling, keyword extraction, and satisfaction scoring. The `company_response` field lets you see how brands handle complaints.

#### E-commerce Data Enrichment

Supplement product catalogs with real-world review data. The scraper's output fields map cleanly onto product listing schemas for marketplace applications.

### How to use Trustpilot Reviews Scraper

1. **Go to the Actor page** in [Apify Console](https://console.apify.com) and click **Try** or **Run**.
2. **Enter the company URL** — paste the full Trustpilot review page URL for the company you want (e.g., `https://www.trustpilot.com/review/example.com`).
3. **Set your options** — choose how many reviews to scrape (up to 500), optionally filter by minimum star rating, and pick a sort order (newest, highest rated, lowest rated, most relevant).
4. **Run the Actor** — click **Start** and the scraper will work through the review pages automatically.
5. **Get your data** — once the run finishes, download the dataset as JSON, CSV, Excel, or HTML from the **Output** tab.

### Input

Configure the run with these fields in the Input tab:

| Field | Type | Required | Default | Description |
| ------- | ------ | ---------- | --------- | ------------- |
| `company_url` | string | Yes | — | Full Trustpilot review URL (e.g., `https://www.trustpilot.com/review/www.amazon.com`) |
| `max_results` | integer | No | 25 | Maximum reviews to scrape (1–500) |
| `min_rating` | integer | No | 0 | Minimum star rating to include (0 = all, 1–5) |
| `sort` | string | No | `newest` | Sort order: `newest`, `most_relevant`, `highest`, `lowest` |

#### Example input

```json
{
  "company_url": "https://www.trustpilot.com/review/www.amazon.com",
  "max_results": 50,
  "min_rating": 3,
  "sort": "newest"
}
````

### Output

The Actor pushes each review as one dataset item. Here's a representative example:

```json
{
  "author": "John D.",
  "rating": 5,
  "title": "Great service and fast delivery",
  "body": "I've been using this service for months and it's been consistently reliable. Highly recommend.",
  "date": "2025-06-15",
  "company_response": "Thanks for your review, John! We're glad you're happy with the service.",
  "is_verified": true,
  "review_url": "https://www.trustpilot.com/reviews/abc123"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel directly from the **Output** tab after each run.

#### Data table

| Field | Type | Description |
| ------- | ------ | ------------- |
| `author` | string | Display name of the reviewer |
| `rating` | integer | Star rating from 1 to 5 |
| `title` | string | Review title or headline |
| `body` | string | Full review text |
| `date` | string | Review date in ISO format (YYYY-MM-DD) |
| `company_response` | string or null | Company's public reply, if any |
| `is_verified` | boolean | Whether Trustpilot lists the reviewer as verified |
| `review_url` | string | Direct permalink to the review |

### Pricing / Cost estimation

The Actor uses pay-per-event (PPE) pricing:

- **First 10 results per run are free**
- **$0.005 per result** after the first 10
- **$0.00005 per run start**

For example, scraping 100 reviews on a single run would cost approximately $0.00005 + (90 × $0.005) = **$0.45**. Because the Actor stops automatically once it reaches `max_results`, you always know the maximum cost upfront.

The Apify free tier includes a monthly usage grant, so small-scope runs often cost nothing.

### Tips and advanced options

- **Use the sort parameter** to control which reviews appear first. The `sort` field maps directly to Trustpilot's built-in sort options.
- **Combine with other Actors** — pipe the output dataset into a sentiment analysis Actor or a data transformation pipeline.
- **Schedule recurring runs** — set up a daily or weekly schedule in Apify Console to track review trends over time.
- **Limit compute units** by setting `max_results` to the minimum you actually need. Each page contains ~20 reviews on average.
- **Increase accuracy** with higher `max_results` for statistical analyses — more data points mean more reliable averages.

### FAQ, disclaimers, and support

**Is scraping Trustpilot legal?** Scraping publicly available data for personal or research purposes is generally permitted, but you should review Trustpilot's Terms of Service and consult legal counsel for commercial use. This Actor is designed to respect website resources by implementing rate limiting and controlled concurrency.

**What if I run into issues?** Check the **Issues** tab on GitHub for known problems and workarounds. If you don't find what you need, open a new issue with detailed logs and we'll look into it.

**Can you build a custom scraper for my needs?** Yes — Apify's team can build custom Actors for specific websites, data formats, or integration requirements. Reach out through the Apify platform.

**Known limitations:** The Actor uses HTTP requests (no browser rendering), so it cannot scrape reviews that require JavaScript-based rendering to appear. Trustpilot's HTML structure may change over time, which could temporarily break selectors. If that happens, the Actor will be updated accordingly.

# Actor input Schema

## `company_url` (type: `string`):

Full URL to the Trustpilot review page (e.g., https://www.trustpilot.com/review/www.amazon.com)

## `max_results` (type: `integer`):

Maximum number of reviews to scrape (max: 500)

## `min_rating` (type: `integer`):

Only scrape reviews with at least this rating (0 = no filter, 1-5 = minimum stars)

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

How to sort reviews on Trustpilot

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

Proxy settings for anti-bot protection. Residential proxies recommended for Trustpilot.

## Actor input object example

```json
{
  "company_url": "https://www.trustpilot.com/review/www.amazon.com",
  "max_results": 25,
  "min_rating": 0,
  "sort": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

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

No description

# 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 = {
    "company_url": "https://www.trustpilot.com/review/www.amazon.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ef12/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 = { "company_url": "https://www.trustpilot.com/review/www.amazon.com" }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ef12/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 for any company. Get review text, star ratings, author names, dates, and company responses. Filter by rating and sort by newest or most relevant.",
        "version": "0.0",
        "x-build-id": "kXHZpR2WJHBawvIB1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ef12~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ef12-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/ef12~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ef12-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/ef12~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ef12-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": [
                    "company_url"
                ],
                "properties": {
                    "company_url": {
                        "title": "Company Review URL",
                        "type": "string",
                        "description": "Full URL to the Trustpilot review page (e.g., https://www.trustpilot.com/review/www.amazon.com)"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape (max: 500)",
                        "default": 25
                    },
                    "min_rating": {
                        "title": "Minimum Rating Filter",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only scrape reviews with at least this rating (0 = no filter, 1-5 = minimum stars)",
                        "default": 0
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "newest",
                            "most_relevant",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "How to sort reviews on Trustpilot",
                        "default": "newest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for anti-bot protection. Residential proxies recommended for Trustpilot.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
