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

Scrape Trustpilot reviews for any company. Extract ratings, review text, dates, verified purchase status, and company responses. Ideal for brand monitoring, competitor analysis, and customer feedback.

- **URL**: https://apify.com/fatihai-tools/trustpilot-reviews-scraper.md
- **Developed by:** [fatih dağüstü](https://apify.com/fatihai-tools) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Trustpilot Reviews Scraper

Extract customer reviews, star ratings, reviewer details, and company information from any Trustpilot business page — at scale, without a login.

**$3 per 1,000 reviews scraped.** No monthly fees. Pay only for what you use.

---

### What This Actor Does

The Trustpilot Reviews Scraper fetches public review data from `trustpilot.com/review/{domain}` pages. It extracts the full review dataset including reviewer names, star ratings, review text, dates, verification status, company replies, and company-level metrics.

Works with any public Trustpilot business page. No API key required. No login required.

---

### Key Features

- **Bulk scraping**: Scrape multiple companies in a single run
- **Full pagination**: Automatically follows all pages until `maxReviews` is reached
- **Rating filter**: Skip reviews below a minimum star threshold
- **Language filter**: Scrape reviews in a specific language (English, German, French, etc.)
- **Verified badge detection**: Know which reviews are Trustpilot-verified
- **Company replies**: Capture the company's response to each review
- **Residential proxies**: Uses Apify's residential proxy pool for reliable results
- **Polite scraping**: 2–4 second delays between requests to avoid rate limits

---

### Use Cases

- **Reputation monitoring**: Track what customers say about your brand over time
- **Competitive intelligence**: Analyze competitor reviews to find their weaknesses
- **Lead generation**: Identify dissatisfied customers of competitors who may be open to switching
- **Market research**: Aggregate review data across an industry vertical
- **Sentiment analysis**: Feed reviews into NLP pipelines to detect trends
- **Review management**: Monitor and respond faster by exporting new reviews daily
- **Due diligence**: Research a company before partnering or investing

---

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `companyUrls` | array | `[]` | Trustpilot URLs (e.g. `https://www.trustpilot.com/review/stripe.com`) |
| `companyNames` | array | `[]` | Domain names (e.g. `stripe.com`, `hubspot.com`) |
| `maxReviews` | integer | `100` | Max reviews per company (1–10,000) |
| `minRating` | integer | `1` | Minimum star rating (1–5). `1` = all reviews |
| `language` | string | `all` | Language filter: `en`, `de`, `fr`, `es`, `it`, `nl`, `pt`, `all` |
| `sortBy` | string | `recency` | Sort order: `recency` or `relevance` |
| `proxy` | object | RESIDENTIAL | Proxy configuration |

You must provide either `companyUrls` or `companyNames` (or both).

---

### Output Fields

Each result in the dataset contains:

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Unique Trustpilot review ID |
| `reviewerName` | string | Reviewer display name |
| `reviewerCountry` | string | ISO country code (e.g. `US`, `GB`) |
| `reviewerTotalReviews` | integer | Total reviews by this reviewer |
| `rating` | integer | Star rating 1–5 |
| `title` | string | Review headline |
| `text` | string | Full review body text |
| `language` | string | Review language code |
| `datePublished` | string | ISO 8601 publish date |
| `dateExperienced` | string | ISO 8601 experience date |
| `dateUpdated` | string | ISO 8601 last update date |
| `isVerified` | boolean | Whether the review is Trustpilot-verified |
| `verificationLevel` | string | `invited`, `verified`, `organic` |
| `verificationSource` | string | How verification happened |
| `source` | string | Review source (e.g. `BasicLink`, `Organic`) |
| `likes` | integer | Helpful votes on the review |
| `replyFromCompany` | object | `{ text, date }` if company replied, else `null` |
| `companyName` | string | Company display name |
| `companyDomain` | string | Company domain (e.g. `stripe.com`) |
| `companyRating` | number | Overall trust score (1.0–5.0) |
| `companyStars` | integer | Overall star rating (1–5) |
| `companyTotalReviews` | integer | Total reviews on Trustpilot |
| `reviewUrl` | string | Direct URL to the review |

---

### Example Output

```json
{
  "reviewId": "65f1a2b3c4d5e6f7a8b9c0d1",
  "reviewerName": "Sarah M.",
  "reviewerCountry": "US",
  "reviewerTotalReviews": 3,
  "rating": 5,
  "title": "Excellent payment processing solution",
  "text": "We've been using Stripe for two years and the reliability has been outstanding. The developer documentation is exceptional and integration was straightforward.",
  "language": "en",
  "datePublished": "2024-03-10T14:22:00.000Z",
  "dateExperienced": "2024-03-01T00:00:00.000Z",
  "dateUpdated": null,
  "isVerified": true,
  "verificationLevel": "invited",
  "verificationSource": "invitation",
  "source": "BasicLink",
  "likes": 4,
  "replyFromCompany": {
    "text": "Thank you for the kind words! We're glad to hear the integration went smoothly.",
    "date": "2024-03-11T09:15:00.000Z"
  },
  "companyName": "Stripe",
  "companyDomain": "stripe.com",
  "companyRating": 1.8,
  "companyStars": 2,
  "companyTotalReviews": 16849,
  "reviewUrl": "https://www.trustpilot.com/reviews/65f1a2b3c4d5e6f7a8b9c0d1"
}
````

***

### Pricing

**$3 per 1,000 reviews** (PPE — Pay Per Event).

| Reviews | Cost |
|---------|------|
| 100 | $0.30 |
| 1,000 | $3.00 |
| 5,000 | $15.00 |
| 10,000 | $30.00 |

Proxy costs are included. No subscription required.

***

### How to Use

#### Option 1: By URL

```json
{
  "companyUrls": [
    "https://www.trustpilot.com/review/stripe.com",
    "https://www.trustpilot.com/review/shopify.com"
  ],
  "maxReviews": 500,
  "minRating": 1,
  "language": "en"
}
```

#### Option 2: By Domain Name

```json
{
  "companyNames": ["stripe.com", "shopify.com", "hubspot.com"],
  "maxReviews": 200,
  "minRating": 3,
  "language": "all"
}
```

#### Option 3: Only 1-Star Reviews (Competitor Research)

```json
{
  "companyNames": ["competitor.com"],
  "maxReviews": 1000,
  "minRating": 1,
  "sortBy": "recency"
}
```

***

### Competitor Comparison

| Tool | Price per 1K results | Login Required | Pagination | Company Reply |
|------|---------------------|----------------|------------|---------------|
| **This Actor** | **$3** | No | Yes (all pages) | Yes |
| Apify Trustpilot Actor (others) | $5–$15 | No | Partial | Sometimes |
| DataForSEO Trustpilot API | $10–$20 | API key | Yes | No |
| ScraperAPI custom | $25+ setup | No | Manual | No |
| Octoparse templates | $75+/mo | No | Limited | No |

This actor extracts data directly from Trustpilot's built-in Next.js data layer (`__NEXT_DATA__`), giving you structured JSON without fragile HTML parsing.

***

### FAQ

**Does this require a Trustpilot account or API key?**
No. Trustpilot review pages are fully public. No login or API key is needed.

**How many reviews can I scrape?**
Up to 10,000 reviews per company per run. You can run multiple times for larger datasets.

**Can I scrape reviews in multiple languages?**
Yes. Set `language` to `all` to get reviews in every language, or specify a language code like `en`, `de`, `fr`.

**How fresh is the data?**
Data is scraped in real-time from Trustpilot. Each run fetches the latest reviews.

**What happens if a company has fewer reviews than maxReviews?**
The actor stops automatically when all available reviews have been scraped.

**Can I filter for only negative reviews?**
Set `minRating` to `1` and `sortBy` to `recency` to get all reviews. There is no max-rating filter, but you can filter the output dataset by rating after scraping.

**Is this against Trustpilot's terms of service?**
This actor scrapes publicly available review data. We recommend using it for legitimate business purposes such as market research, sentiment analysis, and reputation monitoring. Always comply with applicable laws.

**How long does it take?**
With residential proxies and 2–4 second delays, expect ~10 reviews per minute. 1,000 reviews takes ~100 minutes.

**Do you support scheduled runs?**
Yes. Use Apify's built-in scheduler to run this actor daily, weekly, or at any interval to keep your review database fresh.

***

### Related Actors by intelligent\_yaffle

Looking for more data? Check our other scrapers:

- **[Google Maps Scraper](https://apify.com/intelligent_yaffle/google-maps-scraper)** — Extract business listings, reviews, and contact info from Google Maps
- **[LinkedIn Company Scraper](https://apify.com/intelligent_yaffle/linkedin-company-scraper)** — Scrape company profiles and employee data from LinkedIn
- **[LinkedIn Employees Scraper](https://apify.com/intelligent_yaffle/linkedin-company-employees)** — Extract employee lists from LinkedIn company pages
- **[Apollo.io Scraper](https://apify.com/intelligent_yaffle/apollo-scraper)** — Extract B2B contact data from Apollo.io
- **[G2 Reviews Scraper](https://apify.com/intelligent_yaffle/g2-reviews-scraper)** — Scrape software reviews from G2.com
- **[Capterra Reviews Scraper](https://apify.com/intelligent_yaffle/capterra-scraper)** — Extract reviews from Capterra software listings
- **[Yelp Scraper](https://apify.com/intelligent_yaffle/yelp-scraper)** — Scrape business listings and reviews from Yelp

***

### Technical Notes

- Extracts data from Trustpilot's `__NEXT_DATA__` JSON (no fragile CSS selector parsing)
- Uses `gotScraping` + `cheerio` — lightweight, no browser needed
- Residential proxy rotation prevents IP blocks
- Automatic retry logic on failed requests
- Handles pagination, rate limiting, and edge cases gracefully
- Compatible with Apify's dataset export (JSON, CSV, Excel, JSONL, XML)

***

### Support

Questions or issues? Contact us through the Apify platform or open an issue.

Built with care by [intelligent\_yaffle](https://apify.com/intelligent_yaffle).

# Actor input Schema

## `companyUrl` (type: `string`):

Full Trustpilot URL for the company (e.g. https://www.trustpilot.com/review/amazon.com). If provided, takes priority over companyName.

## `companyName` (type: `string`):

Company domain or name as it appears in the Trustpilot URL (e.g. amazon.com or airbnb.com). Used if companyUrl is not provided.

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

Maximum number of reviews to scrape.

## Actor input object example

```json
{
  "companyUrl": "https://www.trustpilot.com/review/amazon.com",
  "companyName": "amazon.com",
  "maxReviews": 50
}
```

# 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("fatihai-tools/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("fatihai-tools/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 fatihai-tools/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fatihai-tools/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. Extract ratings, review text, dates, verified purchase status, and company responses. Ideal for brand monitoring, competitor analysis, and customer feedback.",
        "version": "0.0",
        "x-build-id": "kLWBpKXG4WKn5267X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fatihai-tools~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fatihai-tools-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/fatihai-tools~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fatihai-tools-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/fatihai-tools~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fatihai-tools-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": {
                    "companyUrl": {
                        "title": "Company URL",
                        "type": "string",
                        "description": "Full Trustpilot URL for the company (e.g. https://www.trustpilot.com/review/amazon.com). If provided, takes priority over companyName."
                    },
                    "companyName": {
                        "title": "Company Name / Domain",
                        "type": "string",
                        "description": "Company domain or name as it appears in the Trustpilot URL (e.g. amazon.com or airbnb.com). Used if companyUrl is not provided."
                    },
                    "maxReviews": {
                        "title": "Max Reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
