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

Automatically scrape Trustpilot reviews, ratings, and customer feedback data. Extract reviewer information, timestamps, response data, and sentiment metrics from any business profile. Perfect for reputation monitoring, competitor analysis, and customer insights.

- **URL**: https://apify.com/alexist/trustpilot-reviews-scraper.md
- **Developed by:** [Alex](https://apify.com/alexist) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

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: Extract Customer Reviews & Ratings Data

### What is Trustpilot and Why Scrape It?

Trustpilot is one of the world's largest review platforms, hosting millions of verified customer reviews across businesses worldwide. Companies use Trustpilot to build trust and transparency, while consumers rely on it to make informed purchasing decisions.

Scraping Trustpilot data provides valuable insights for:
- **Reputation management**: Monitor your brand's customer sentiment in real-time
- **Competitive intelligence**: Analyze competitor reviews and identify market gaps
- **Product development**: Extract feedback to improve offerings
- **Market research**: Understand customer pain points and preferences across industries

### Scraper Overview

This Trustpilot Reviews Scraper efficiently extracts comprehensive review data from any company profile on Trustpilot. It collects not just basic reviews, but detailed metadata including consumer profiles, response patterns, and engagement metrics.

**Key Features:**
- Extracts up to unlimited reviews per URL (configurable via `max_items_per_url`)
- Supports pagination across multiple review pages
- Captures complete review metadata and consumer information
- Handles proxy configuration for reliable data collection
- Error handling with `ignore_url_failures` option
- Exports data in JSON, CSV, Excel, or XML formats

**Ideal for:** Marketing teams, business analysts, reputation managers, researchers, and e-commerce professionals.

### Input Configuration

#### Input Format

The scraper accepts JSON configuration with the following structure:
```json
{
  "proxy": {
    "useApifyProxy": false
  },
  "max_items_per_url": 20,
  "ignore_url_failures": true,
  "urls": [
    "https://www.trustpilot.com/review/texasbaycu.org?page=2"
  ]
}
````

#### Example Screenshot:

![](https://i.ibb.co/6Js9h5gQ/Screenshot-from-2025-12-10-00-07-32.png)

#### Parameter Explanation:

- **`proxy`**: Proxy configuration to avoid bot detection. Set `useApifyProxy: true` to use Apify's proxy service, or configure custom proxies
- **`max_items_per_url`**: Maximum number of reviews to extract per URL (default: 20). Set higher for comprehensive data collection
- **`ignore_url_failures`**: Continue scraping other URLs if one fails (recommended: true)
- **`urls`**: Array of Trustpilot review page URLs.

#### URL Requirements:

- Must be valid Trustpilot review pages
- Can include pagination parameters (`?page=N`)
- Supports any company domain on Trustpilot
- Multiple URLs allowed for batch processing

### Output Data Structure

The scraper returns detailed review data with the following fields:

#### Core Review Information:

- **`ID`**: Unique identifier for the review - useful for deduplication and tracking
- **`Text`**: Full review content - the customer's written feedback
- **`Rating`**: Star rating (1-5) - quantitative satisfaction metric
- **`Title`**: Review headline - quick summary of customer opinion
- **`Dates`**: Timestamp information - when review was posted/updated

#### Review Status & Moderation:

- **`Filtered`**: Boolean indicating if review was filtered by platform
- **`Pending`**: Review moderation status
- **`Labels`**: Tags or categories assigned to the review
- **`Has Unhandled Reports`**: Flags reviews with unresolved reports

#### Engagement Metrics:

- **`Likes`**: Number of helpful votes - indicates review usefulness
- **`Source`**: Origin of the review (verified purchase, invitation, etc.)
- **`Report`**: User-generated flags or complaints about the review

#### Consumer Profile:

- **`Consumer`**: Reviewer information (name, profile details)
- **`Consumers Review Count on Same Domain`**: Total reviews by this user for this company - helps identify power reviewers
- **`Consumers Review Count on Same Location`**: Geographic review patterns - useful for regional analysis
- **`Location`**: Reviewer's geographic location

#### Business Response:

- **`Reply`**: Company's response to the review - measures engagement
- **Analysis tip**: Track reply rate and response time for customer service metrics

#### Additional Context:

- **`Product Reviews`**: Specific product mentions or SKU references
- **`Language`**: Review language - enables multilingual analysis

#### Example Output:

```json
{
  {
  "id": "6913a27f7f25350205d48d8c",
  "filtered": false,
  "pending": false,
  "text": "Staff is always amazing and helpful and Carlos was very outstanding at helping us get to the bottom of things on fixing our account. Very quick worker.",
  "rating": 5,
  "labels": {
    "merged": null,
    "verification": {
      "is_verified": false,
      "created_date_time": "2025-11-11T22:54:23.000Z",
      "review_source_name": "Organic",
      "verification_source": "invitation",
      "verification_level": "not-verified",
      "has_dach_exclusion": false
    }
  },
  "title": "Staff is always amazing and helpful and…",
  "likes": 0,
  "source": "Organic",
  "dates": {
    "experienced_date": "2025-11-11T00:00:00.000Z",
    "published_date": "2025-11-11T22:54:23.000Z",
    "updated_date": null,
    "submitted_date": null
  },
  "report": null,
  "has_unhandled_reports": false,
  "consumer": {
    "id": "6913a27840641432393c7ace",
    "display_name": "Brandon Castillo",
    "image_url": "https://user-images.trustpilot.com/6913a27840641432393c7ace/73x73.png",
    "number_of_reviews": 1,
    "country_code": "US",
    "has_image": true,
    "is_verified": false
  },
  "reply": {
    "message": "Thank you for sharing your feedback! We truly appreciate it. It's wonderful to see that you received 5-star experience. Have a fantastic day!",
    "published_date": "2025-11-13T21:09:23.000Z",
    "updated_date": null
  },
  "consumers_review_count_on_same_domain": 1,
  "consumers_review_count_on_same_location": null,
  "product_reviews": [],
  "language": "en",
  "location": null,
  "from_url": "https://www.trustpilot.com/review/texasbaycu.org?page=2"
}
}
```

### How to Use the Scraper

1. **Set Up Input**: Copy the JSON configuration template and modify the `urls` array with target Trustpilot pages
2. **Configure Limits**: Adjust `max_items_per_url` based on your needs (20-100 for sampling, 500+ for comprehensive analysis)
3. **Enable Proxy**: Set `useApifyProxy: true` for reliable scraping without IP blocks
4. **Run Scraper**: Execute and monitor the extraction progress
5. **Export Data**: Download results in your preferred format (JSON for analysis, CSV for spreadsheets)

#### Best Practices:

- Start with lower `max_items_per_url` values to test before full scraping
- Use proxies for large-scale data collection
- Include pagination URLs to capture complete review history
- Enable `ignore_url_failures` when scraping multiple companies

#### Common Issues:

- **Empty results**: Verify URL format and company domain spelling
- **Rate limiting**: Enable proxy configuration
- **Missing fields**: Some reviews may have incomplete data (e.g., no company reply)

### Business Applications & Benefits

#### Reputation Management:

Monitor brand sentiment trends, identify recurring complaints, and measure response effectiveness. Track reply rates and resolution patterns to improve customer service.

#### Competitive Analysis:

Compare your review ratings and volume against competitors. Identify their strengths and weaknesses through customer feedback analysis.

#### Product Development:

Extract product-specific feedback to guide feature improvements. Analyze recurring feature requests and pain points.

#### Market Research:

Understand customer expectations and industry standards. Identify emerging trends through review language analysis.

#### Time Savings:

Automate what would take hours of manual copying. Process thousands of reviews in minutes rather than days.

### Conclusion

The Trustpilot Reviews Scraper transforms customer feedback into actionable business intelligence. Whether monitoring your brand reputation, analyzing competitors, or conducting market research, this tool provides the comprehensive data extraction you need.

**Ready to start?** Configure your first scraping run with the template above and unlock valuable customer insights from Trustpilot.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the bussiness review page urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.trustpilot.com/review/texasbaycu.org?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.trustpilot.com/review/texasbaycu.org?page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexist/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 = {
    "urls": ["https://www.trustpilot.com/review/texasbaycu.org?page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("alexist/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 '{
  "urls": [
    "https://www.trustpilot.com/review/texasbaycu.org?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call alexist/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper",
        "description": "Automatically scrape Trustpilot reviews, ratings, and customer feedback data. Extract reviewer information, timestamps, response data, and sentiment metrics from any business profile. Perfect for reputation monitoring, competitor analysis, and customer insights.",
        "version": "0.0",
        "x-build-id": "GjKKrm2IVrdWjaqFh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alexist~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alexist-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/alexist~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alexist-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/alexist~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alexist-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": {
                    "urls": {
                        "title": "URLs of the bussiness review page urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the bussiness review page urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```