How to Scrape Trustpilot Reviews (2026)

TL;DR

Trustpilot renders its review data server side inside a __NEXT_DATA__ script tag, so you can scrape it with plain Python requests and no browser. Extract the buildId from any company page, then page through the hidden JSON endpoint to pull 20 structured reviews per request. Public pagination is capped at around 10 pages per view, so segment by star rating and date filters to collect full datasets, and route requests through rotating proxies once you scale past a few companies.

Trustpilot review data is useful for sentiment analysis, competitor monitoring, and lead generation, but there is no bulk export button, and the anti-bot systems block careless scrapers fast. The data sits in a predictable place though, and a few lines of Python can pull it cleanly. In this article, we'll explore where Trustpilot stores its reviews, how to scrape them through the hidden JSON endpoint, how to get past the pagination cap, and how to avoid blocks at scale.

Where Trustpilot Stores Its Review Data

Trustpilot is built on Next.js, and that changes how you should approach it. Every company page ships a script tag with the id __NEXT_DATA__ holding the full page state as JSON: company details, TrustScore, and the first page of reviews. The data is server-rendered, so it sits in the raw HTML before any JavaScript runs.

This matters more than it sounds. Most guides tell you to parse review cards with CSS selectors like styles_reviewCardInner__EwDq2. Those class names are hashed and change whenever Trustpilot ships an update, so selector-based scrapers break constantly. The JSON structure is far more stable, and it means you don't need a headless browser. A plain HTTP client gets you everything.

Scraping Trustpilot Reviews with Python

Trustpilot loads additional review pages through a JSON endpoint under the /_next/data/ path. The endpoint contains a buildId, and this is the part most tutorials get wrong. It rotates every time Trustpilot deploys new code, so hardcoding it gives you a scraper that dies within days. Fetch it fresh on every run.

Here is the full flow:

1. Install the library with pip install requests.
2. Fetch the company page and extract the current buildId.
3. Page through the JSON endpoint and collect the reviews.

import re
import time
import requests

company = "www.example.com"

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    "Accept-Language": "en-US,en;q=0.9",
}

# Step 1: grab the current build ID from the company page
page = requests.get(f"https://www.trustpilot.com/review/{company}", headers=headers)
build_id = re.search(r'"buildId":"(.*?)"', page.text).group(1)

# Step 2: page through the review endpoint
api_url = f"https://www.trustpilot.com/_next/data/{build_id}/review/{company}.json"
reviews = []

for page_num in range(1, 11):
    params = {"businessUnit": company, "page": page_num, "sort": "recency"}
    resp = requests.get(api_url, params=params, headers=headers)
    data = resp.json()["pageProps"]
    reviews.extend(data["reviews"])
    if page_num >= data["filters"]["pagination"]["totalPages"]:
        break
    time.sleep(1.5)

print(f"Collected {len(reviews)} reviews")

Each page returns 20 reviews as structured JSON, including the rating, title, text, dates, and reviewer details. No HTML parsing involved.

Also Read: How to Set Up Rotating Proxies for Web Scraping (2026)

Getting Past the Pagination Cap

Trustpilot gates public review pagination at around 10 pages per view, roughly 200 reviews. Past that point, the website pushes a login prompt and deeper pages stop resolving. Most tutorials skip this detail, which is why scrapers stall on large companies.

The workaround is filtering. The endpoint accepts the same query parameters as the website, and each filtered view gets its own pagination. Instead of one giant list, split the job into segments: one-star reviews, then two-star, and so on. The five-star ratings alone multiply your ceiling by five, and date windows cover the rest.

params = {
    "businessUnit": company,
    "page": 1,
    "stars": "1",
    "date": "last6months",
}

Combine star, date, and language filters, and you can reconstruct nearly the full review history of large companies.

Avoiding Blocks at Scale

A handful of requests with realistic headers will go through fine. The problems start at volume. Trustpilot tracks request frequency per IP, and past its threshold you start seeing 403 responses and CAPTCHA challenges. Pacing helps, but it caps your throughput.

The fix is spreading requests across IPs. Rotating residential proxies are the safest option because the traffic looks like ordinary visitors, which keeps success rates high on review platforms. For smaller jobs pulling a few hundred reviews, datacenter proxies are faster and cheaper, and Trustpilot tolerates them at low volume.

proxies = {
    "http": "http://user:pass@gateway.proxyon.io:8000",
    "https": "http://user:pass@gateway.proxyon.io:8000",
}

resp = requests.get(api_url, params=params, headers=headers, proxies=proxies)

Keep the delays even with rotation in place. The goal is to look boring, not fast.

Also Read: How to Do Web Scraping Without Getting Blocked (2026 Guide)

FAQ Section

Is it legal to scrape Trustpilot reviews?

Scraping publicly visible data is generally treated as legal in most jurisdictions, but Trustpilot's terms of service prohibit automated collection, and reviews contain personal data like reviewer names, which brings GDPR into play for EU users. Collect at a respectful rate, drop personal fields you don't need, and get legal advice if the data feeds a commercial product.

Does Trustpilot have an official API?

Yes, but it's not built for bulk collection. Trustpilot's API is aimed at businesses managing their own profile and requires a business account with API access. If you need reviews across many companies you don't own, scraping is the practical route.

Do I need a headless browser like Playwright?

No. The review data is server rendered inside the __NEXT_DATA__ script tag, so plain HTTP requests get everything. A headless browser only adds memory overhead and a larger detection surface here.

Why did my Trustpilot scraper suddenly stop working?

The most common cause is a stale buildId. Trustpilot rotates it on every deployment, and requests against the old endpoint start failing. If your scraper extracts the buildId at runtime instead of hardcoding it, it survives every deploy.

Final Thoughts

Scraping Trustpilot comes down to three things: pull from the JSON instead of parsing HTML, fetch the buildId fresh on every run, and segment with filters when a company holds more than 200 reviews. For small jobs, careful pacing on a single IP is enough. Once you scale past a few companies, rotating proxies become the difference between a dataset and a ban.