# Trustpilot Reviews Scraper & Trustpilot API: No 200 Cap (`hyperbach/trustpilot-reviews-scraper`) Actor

Trustpilot reviews API and scraper, no login: scrape every Trustpilot review of a business by domain or URL, past the 200 cap; rating, text, dates, reviewer, reply; export the company's TrustScore, star split, AI summary and a completeness verdict. All languages, star, topic and keyword filters.

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

## Pricing

from $0.25 / 1,000 reviews

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Trustpilot Reviews Scraper & Trustpilot API: No 200 Cap

**Every review of a business on Trustpilot, logged out: a domain or a Trustpilot review URL in, one row per review out — rating, title, text, the published / experienced / updated dates, language, likes, the verified flag with its level and source, the reviewer's id, name, country, review count and avatar, the business's reply with its dates, the moderation flags — past Trustpilot's 10-page cap by the slices the page serves (languages, stars, topics, keywords), every review once.** One free `business` row per business carries the summary the page shows (TrustScore, stars, the review counts, the star and language split, categories, the contact block, the claimed and verification flags, the reply behaviour, Trustpilot's own AI summary and topic summaries, similar businesses; the transparency page on request) and a completeness verdict against Trustpilot's own count of the asked view: COMPLETE, TRUNCATED, CAPPED or PARTIAL, with the numbers. Trustpilot's filters (stars, one language or all, a date preset or an exact cutoff, verified only, with replies only, topics, a keyword, the sort) go into the request. A business not on Trustpilot, a view with no review, a value that is no business: free typed rows. Your own id travels with every row. No login, no Trustpilot account, no API key, proxies handled for you.

### Why this Trustpilot reviews scraper

- **Past the 200-review cap, with a verdict.** Trustpilot shows 20 reviews a page and 10 pages a view logged out; page 11 is the login. The lane's tools stop at 200, 400 or about 1,000 and never say where the list ended (the buyers' most frequent complaint on every rival). Here each business is read view by view: the asked view's 200 newest, then the slices the page itself serves — every language of the business, every star rating, the 25 topics, keywords learned from the reviews already read — every review once, until Trustpilot's own count is reached or the slices run dry. The free `business` row states that count (`view_count`), how many distinct reviews were read (`reviews_found`), how many views and calls it took, and the verdict: COMPLETE, TRUNCATED (the rest sits behind Trustpilot's login), CAPPED (your limit) or PARTIAL (a refusal). On our tests: 6,074 of www.grammarly.com's 10,400 reviews in 15.6 minutes, 767 of a 905-review one-star view, a 230-review two-star view whole in 23 calls.
- **The page's own record, every field.** Each review row carries what the review page carries: the rating, title and text, the published date to the second, the date of experience and the update date, the language, the likes, the verification flag with Trustpilot's level and source, the review source (organic, invitation, basic link), the reviewer's id, display name, country, review count and avatar, the business's reply with its published and updated dates, the moderation flags (pending, filtered, under moderation, unhandled reports), the business location and product reviews where the business has them — plus `reply_delay_days` and `is_negative` derived for you.
- **All languages by default.** Trustpilot shows a US visitor the English view by default (2,957 of pipedrive.com's 3,430 reviews), and the lane's leader reads only that. Here `language` defaults to `all`; set one code for one language. Every language the business has reviews in is listed on the business row with its count.
- **The business summary, free, on its own row.** TrustScore, stars, the review counts (all, shown, the last 12 months), the star and language split, the categories, the contact block (e-mail, phone, address), claimed and closed flags, the verification flags, the reply behaviour (reply rate, days to reply), Trustpilot's AI summary and its topic summaries, the similar businesses Trustpilot lists; with `includeTransparency`, the transparency page: how the reviews were collected, the monthly counts per star, the reports and their outcomes. One row per business, never repeated on every review.
- **Trustpilot's own filters, on the request.** Stars (one or several), a language or all, Trustpilot's date presets, an exact `publishedAfter` cutoff for scheduled runs (the walk stops at the first older review), verified only, with replies only, topics, a keyword inside the reviews, the recency or relevance sort — each one is the page's own filter (every row passes on its own fields), and each business in a list can carry its own.
- **Honest runs.** A domain Trustpilot has no page for is a free `not_found` row; a view with no review a free `empty` row; a value that is no business a free `invalid` row; a business repeated with the same filters a free `duplicate` row; a business left unread at your cap or the time limit a free `not_read` row; a refusal the run could not pass a free `failed` row. No run ends green with nothing on a valid business, and a review is charged once a run whatever inputs overlap.
- **No browser in most runs, then plain HTTP.** Trustpilot's bot check is cleared once on our side and the pass is shared: a run takes it in about a second and opens no browser of its own (only when that pass is missing or refused does a run clear the check itself, 22 seconds at the median of 60 browser loads on our tests). Every page is one plain HTTP call of 81 KB for 20 reviews. On our tests a run of 1 to 5 reviews took 7 to 9 seconds on a warm Apify node (27 to 59 seconds when the node first pulled the image), and 400 reviews of one business took 51 seconds of reading.

### Who it's for

- **Brand, CX and reputation teams** — every review of your business and your competitors' with the reply and its delay, the star split and the reply behaviour; a scheduled task with `publishedAfter` delivers only the new reviews each day.
- **Market researchers and analysts** — thousands of reviews of a large business past the page cap, in every language, with Trustpilot's own count and a completeness verdict to report against; the 1-star view of a competitor with its topics.
- **Lead-generation and sales tools** — the business summary row per domain (TrustScore, counts, contacts, claimed flag, reply behaviour) for a list of 500 domains in one run with `includeReviews` off.
- **Developers and data teams** — typed rows keyed by `input_index` and your own `input_id`, a free summary row per business with the status and verdict, a run summary to check a pipeline against, every input constrained in the schema.

### Quick start

**The 100 newest reviews of a business, every language**

```json
{
  "business": "pipedrive.com",
  "maxReviewsPerBusiness": 100
}
```

**Every review reachable of a business, with the transparency page**

```json
{
  "business": "pipedrive.com",
  "includeTransparency": true
}
```

**Only the reviews since a date (a scheduled task)**

```json
{
  "businesses": [
    "pipedrive.com",
    "notion.so"
  ],
  "publishedAfter": "2026-09-01",
  "language": "en"
}
```

**The 1- and 2-star English reviews of several businesses, with your ids**

```json
{
  "businesses": [
    {
      "business": "pipedrive.com",
      "id": "crm-1"
    },
    {
      "business": "https://www.trustpilot.com/review/notion.so",
      "id": "notes-2"
    }
  ],
  "stars": "1,2",
  "language": "en"
}
```

### Output

One row per review (and one free summary row per business):

| field | meaning |
|---|---|
| `row_type` | `review` (one review, charged) or `business` (the business summary with the walk's verdict; free beside review rows, charged in a summary-only run). |
| `input_index` | The 1-based position of the input this row answers. |
| `input_label` | The input as you gave it (the domain or URL). |
| `input_id` | Your own `id` from a business object, carried on every row it produces. |
| `status` | A business row: `ok`, `empty` (no review in the asked view), `not_found` (no such business on Trustpilot), `failed` (a refusal or an error, free), `invalid` (a value that is no business), `duplicate` (the same business and filters given twice), `not_read` (left at the cap or the time limit). A review row: `ok`. |
| `status_detail` | Why, in words, when the status is not `ok`. |
| `scraped_at` | When the row was read (ISO 8601, UTC). |
| `business_id` | Trustpilot's business unit id. |
| `business_domain` | The business's Trustpilot slug (its domain as Trustpilot writes it: `www.wix.com`). |
| `business_name` | The business's display name on Trustpilot. |
| `business_url` | The business's review page on Trustpilot. |
| `website_url` | The business's own website, as Trustpilot links it. |
| `logo_url` | The business's logo on Trustpilot. |
| `description` | The business's own description on its Trustpilot page (the text it wrote about itself), when it has one. |
| `trust_score` | Trustpilot's TrustScore (0–5, one decimal). |
| `stars` | The star rating shown on the page (0.5 steps). |
| `reviews_count` | Every review Trustpilot counts for the business (`numberOfReviews`). |
| `reviews_shown` | The reviews the page shows in all languages (reviews under moderation or filtered are not in it). |
| `reviews_last_12_months` | Reviews published in the last 12 months. |
| `star_distribution` | How many reviews carry each rating: `{one, two, three, four, five}`. |
| `language_distribution` | Reviews per language: a list of `{code, name, count}`. |
| `categories` | The business's categories on Trustpilot (names). |
| `category_ids` | The categories' ids (`crm_provider`). |
| `primary_category` | The primary category, or the top-level one. |
| `country_code` | The business's country on Trustpilot. |
| `contact_email` | The business's contact e-mail from its Trustpilot profile. |
| `contact_phone` | The business's phone from its profile. |
| `contact_address` | The business's street address from its profile. |
| `contact_city` | The city line of the address. |
| `contact_zip` | The postal code of the address. |
| `contact_country` | The country of the address. |
| `is_claimed` | Whether the business claimed its profile. |
| `claimed_at` | When the profile was claimed (ISO 8601). |
| `is_closed` | Whether Trustpilot marks the business as closed. |
| `is_temporarily_closed` | Whether Trustpilot marks the business as temporarily closed. |
| `is_collecting_reviews` | Whether the business actively invites reviews through Trustpilot. |
| `has_incentivised_reviews` | Whether Trustpilot flags incentivised reviews on the profile. |
| `uses_ai_responses` | Whether the business replies with Trustpilot's AI responses. |
| `has_subscription` | Whether the business holds a paid Trustpilot subscription. |
| `previously_claimed` | Whether the business profile was claimed before (Trustpilot's own flag). |
| `uses_paid_features` | Whether the business uses Trustpilot's paid features. |
| `locations_count` | The business's locations on Trustpilot. |
| `verification` | Trustpilot's verification flags: `{verifiedUserIdentity, verifiedByGoogle, verifiedPaymentMethod, verifiedByPersona}`. |
| `consumer_alert` | Trustpilot's consumer alert on the profile, when there is one. |
| `reply_rate` | The share of negative reviews the business replied to (percent). |
| `days_to_reply` | The average days the business takes to reply to a negative review. |
| `negative_reviews_count` | Negative reviews Trustpilot counts for the reply behaviour. |
| `negative_reviews_replied` | Negative reviews with a reply. |
| `last_reply_to_negative_at` | When the business last replied to a negative review (ISO 8601). |
| `ai_summary` | Trustpilot's own AI summary of the reviews, as the page shows it. Trustpilot writes it per language: on the all-languages view it is the summary of the business's largest language (one more call), named in `ai_summary_language`. |
| `ai_summary_language` | The language of `ai_summary` and `topic_summaries` (Trustpilot writes them per language). |
| `topic_summaries` | Trustpilot's AI summaries per topic: a list of `{topic, summary}`; per language, like `ai_summary` (null on the all-languages view). |
| `similar_businesses` | Businesses Trustpilot lists as similar: `{domain, name, trust_score, stars, reviews_count}`. |
| `transparency` | With `includeTransparency`: how the reviews were collected (`collecting_methods`), the monthly counts per star (`monthly_distribution`), the 12-month total, star split and reply count (`reviews_12_months`, `stars_distribution`, `reply_count`), the reports and their outcomes (`reports`), the reply rate and the basic-link rate. |
| `review_id` | Trustpilot's review id. |
| `url` | The review's own page on Trustpilot. |
| `rating` | The review's star rating (1–5). |
| `title` | The review's title. |
| `text` | The review's text. |
| `language` | The review's language code. |
| `published_at` | When the review was published (ISO 8601, UTC, to the second). |
| `experienced_at` | The date of experience the reviewer gave. |
| `updated_at` | When the reviewer last updated the review, when they did. |
| `likes` | How many people found the review useful. |
| `is_verified` | Whether Trustpilot marks the review as verified. |
| `verification_level` | Trustpilot's verification level (`verified`, `not-verified`, …). |
| `verification_source` | How the review was verified (`invitation`, …). |
| `review_source` | Where the review came from as Trustpilot labels it (`Organic`, `Invitation`, `Basic link`, …). |
| `source` | Trustpilot's raw `source` value of the review. |
| `reviewer_id` | The reviewer's Trustpilot consumer id. |
| `reviewer_name` | The reviewer's display name. |
| `reviewer_country` | The reviewer's country code. |
| `reviewer_review_count` | How many reviews the reviewer has written on Trustpilot. |
| `reviewer_is_verified` | Whether Trustpilot marks the reviewer's own profile as verified. |
| `reviewer_image_url` | The reviewer's avatar, when they have one. |
| `reviewer_reviews_of_business` | How many reviews the reviewer wrote for this business. |
| `reply_text` | The business's reply to the review, when there is one. |
| `reply_published_at` | When the reply was published (ISO 8601). |
| `reply_updated_at` | When the reply was last updated. |
| `reply_delay_days` | Days from the review to the reply (two decimals), when there is a reply. |
| `is_negative` | `true` on a 1- or 2-star review (a complaint flag derived from the rating). |
| `is_pending` | Whether Trustpilot shows the review as pending. |
| `is_filtered` | Whether Trustpilot filtered the review. |
| `is_under_moderation` | Whether the review is under moderation. |
| `has_unhandled_reports` | Whether the review carries a report not yet handled. |
| `location` | The business location the review is about, when the business has several. |
| `product_reviews` | Product reviews attached to the review, when there are any. |
| `rank` | The review's position in the asked view, newest first: 1 to 200 for the view's own pages; null for a review the deep walk read past the 200-a-view cap. |
| `view` | The query the review was read in (`languages=en&sort=recency`, `languages=en&sort=recency&stars=1`, a topic or a keyword view). |
| `filters` | The business row: the filters the business was read with. |
| `view_count` | The business row: Trustpilot's own count of reviews in the asked view (`pagination.totalCount`). |
| `reviews_found` | The business row: distinct reviews read for the business in this run. |
| `reviews_delivered` | The business row: review rows delivered for the business in this run. |
| `views_read` | The business row: the views the walk read (the asked view and its slices). |
| `calls` | The business row: calls made to Trustpilot for the business. |
| `verdict` | The business row: `COMPLETE` (every review of the asked view read), `TRUNCATED` (Trustpilot's 200-a-view cap left some behind its login), `CAPPED` (your `maxReviewsPerBusiness` or `maxItems`), `PARTIAL` (a refusal or the time limit stopped the walk). |
| `verdict_detail` | The business row: the verdict in words, with the counts. |

Example record:

```json
{
  "row_type": "review",
  "input_index": 2,
  "input_label": "pipedrive.com",
  "input_id": "cursor",
  "status": "ok",
  "status_detail": null,
  "scraped_at": "2026-10-19T02:56:03Z",
  "business_id": "514581950000640005241c4f",
  "business_domain": "pipedrive.com",
  "business_name": "Pipedrive",
  "business_url": null,
  "website_url": null,
  "logo_url": null,
  "description": null,
  "trust_score": null,
  "stars": null,
  "reviews_count": null,
  "reviews_shown": null,
  "reviews_last_12_months": null,
  "star_distribution": null,
  "language_distribution": null,
  "categories": null,
  "category_ids": null,
  "primary_category": null,
  "country_code": null,
  "contact_email": null,
  "contact_phone": null,
  "contact_address": null,
  "contact_city": null,
  "contact_zip": null,
  "contact_country": null,
  "is_claimed": null,
  "claimed_at": null,
  "is_closed": null,
  "is_temporarily_closed": null,
  "is_collecting_reviews": null,
  "has_incentivised_reviews": null,
  "uses_ai_responses": null,
  "has_subscription": null,
  "previously_claimed": null,
  "uses_paid_features": null,
  "locations_count": null,
  "verification": null,
  "consumer_alert": null,
  "reply_rate": null,
  "days_to_reply": null,
  "negative_reviews_count": null,
  "negative_reviews_replied": null,
  "last_reply_to_negative_at": null,
  "ai_summary": null,
  "ai_summary_language": null,
  "topic_summaries": null,
  "similar_businesses": null,
  "transparency": null,
  "review_id": "6ad0fde9134859f14b74a79a",
  "url": "https://www.trustpilot.com/reviews/6ad0fde9134859f14b74a79a",
  "rating": 5,
  "title": "Pipeline Rollout and Support Team",
  "text": "Called on their support desk during a pipeline rollout in Midtown to help fix some messy custom data routing. They actually dug right into our schema and helped straighten out the workflow instead of just parroting a script. The onboarding pace is admittedly a bit rushed, frankly. But the support team knows their technical details inside out. Solid software for managing client pipelines.",
  "language": "en",
  "published_at": "2026-10-15T18:23:05Z",
  "experienced_at": "2026-10-13T00:00:00Z",
  "updated_at": null,
  "likes": 0,
  "is_verified": false,
  "verification_level": "not-verified",
  "verification_source": "invitation",
  "review_source": "Organic",
  "source": "Organic",
  "reviewer_id": "6a3d2c80000ce345908fda76",
  "reviewer_name": "[redacted]",
  "reviewer_country": "US",
  "reviewer_review_count": 4,
  "reviewer_is_verified": null,
  "reviewer_image_url": null,
  "reviewer_reviews_of_business": 1,
  "reply_text": "Hi [redacted],\n\nThank you for the feedback.\nWe’re glad our support team dug into your schema and helped straighten out your custom data routing during the pipeline rollout.\nWe’re also noting your comment that the onboarding pace felt rushed, and we’ll share your comments with the relevant teams.\n\nBest regards,\nPipedrive Team",
  "reply_published_at": "2026-10-16T08:10:20Z",
  "reply_updated_at": null,
  "reply_delay_days": 0.57,
  "is_negative": false,
  "is_pending": false,
  "is_filtered": false,
  "is_under_moderation": false,
  "has_unhandled_reports": false,
  "location": null,
  "product_reviews": null,
  "rank": 2,
  "view": "languages=en&sort=recency",
  "filters": null,
  "view_count": null,
  "reviews_found": null,
  "reviews_delivered": null,
  "views_read": null,
  "calls": null,
  "verdict": null,
  "verdict_detail": null
}
```

### Pricing

**Pay for the reviews a run delivers**, plus one run start; no platform usage is billed to you. The row prices fall with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Review (`review`) | per 1,000 | $0.50 | $0.425 | $0.35 | $0.25 |
| Business summary (summary-only runs) (`business`) | per 1,000 | $4.99 | $4.2415 | $3.493 | $2.495 |
| Run start (`start`) | per run | $0.005 | $0.005 | $0.005 | $0.005 |

A review is **$0.50 per 1,000** on the Free plan ($0.0005 a review) and $0.25 on Business. Each run that delivers a charged row also pays the **run start, $0.005 once** (the container's start and Trustpilot's bot check, cleared once on our side and shared by the runs); a run that delivers no charged row pays nothing at all. So the 200 newest reviews of one business cost $0.105 on the Free plan, 1,000 reviews $0.505, and several businesses in one run share one start. In a summary-only run (`includeReviews` off) each business summary row is the charged row: **$4.99 per 1,000** ($0.00499 a business). Free: the `business` summary row of every business in a run that reads reviews (the counts, the verdict, the status and its reason), a business Trustpilot has no page for (`not_found`), a view with no review (`empty`), a value that is no business (`invalid`), a business repeated with the same filters (`duplicate`), a business left unread at the cap or the time limit (`not_read`), a refusal the run could not pass (`failed`), and the transparency page (`includeTransparency`). A review is charged once a run, whatever inputs overlap. A run that stops early (a timeout, an abort) is charged for the rows it delivered. `maxItems` counts the charged rows; before the first request the log names the price of each row at your plan, the run start and the most the run can cost. A business with no `maxReviewsPerBusiness` in a run with no `maxItems` has no fixed maximum: it reads every review reachable, which Trustpilot's count of the view decides (6,074 rows of a 10,400-review business on our test, about $3.04 on the Free plan); set either limit for a hard maximum, or a charge limit. Enterprise plans have their own rates — the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **One business or many** — Give `business` (a domain such as `pipedrive.com`, or a Trustpilot review URL on any country host; a URL's own `stars`, `languages`, `date`, `verified`, `replies`, `topics`, `search` and `sort` parameters apply) with the run's filters, or list businesses in `businesses` (strings, or objects with their own filters, `maxReviewsPerBusiness` and `id`). A list is the whole run; the run's filters are its defaults. Every row carries `input_index`, `input_label` and your `input_id`, and every business gets one free `business` row with its status and verdict.
- **What a row is** — `row_type` = `review`: one review of a business with the page's record; `rank` is its position in the asked view (1 to 200, newest first under `recency`), null for a review read past the cap through a slice; `view` is the query it was read in. `row_type` = `business`: the free summary of a business — the page's own business block, the filters used, Trustpilot's count of the asked view (`view_count`), `reviews_found`, `reviews_delivered`, `views_read`, `calls`, the `verdict` with its `verdict_detail`, and the `status` with its reason. With `includeReviews` off the business row is the whole answer and is charged as a `business` row.
- **How far a business goes** — `maxReviewsPerBusiness` = 0 (the default) reads every review reachable logged out: the asked view's 10 pages (200 newest), then the slices past them — each language (when the view is `all`), each star, each of the 25 topics, keywords learned from the reviews read — every review once, until Trustpilot's count is reached or a slice gives nothing new. `maxReviewsPerBusiness` = 100 is the 100 newest in the asked order. `maxItems` caps the charged rows of the whole run. The business row's `verdict` and `verdict_detail` say what was read against Trustpilot's `view_count`; a row count that stops short of the count is never silent. Reviews a slice reads past the first 200 are in the slice's own order, not the view's: sort by `published_at` for the newest-first list.
- **Filters and sorts** — `stars` (`1,2`), `language` (`all` or one code), `dateRange` (Trustpilot's presets), `publishedAfter` (an exact date or datetime: the walk reads each view newest first and stops at the first older review, so a scheduled task with its last run's date delivers only what is new), `verifiedOnly`, `withRepliesOnly`, `topics` (Trustpilot's topic ids; several = all of them at once), `keyword` (Trustpilot's review search), `sort` (`recency` or `relevance`: the same 200 reviews of a view, ordered differently). Every filter is Trustpilot's own request parameter (measured against a control on our runs: the count moves and every row passes on its own fields). `publishedAfter` needs `sort` recency.
- **The business summary and the transparency page** — Every business row carries the summary the review page shows. `includeTransparency` adds one call per business for Trustpilot's transparency page into the `transparency` column: how the reviews were collected (organic, invited, automatic, redirected), the counts per month and per star over the last 12 months, the reports and their outcomes, the reply rate. `includeReviews` off reads the summary only (one call per business, two on the all-languages view: Trustpilot writes its AI summary per language, so the business's largest language is read for it) and charges the `business` row instead of reviews.
- **Scheduled runs: only the new reviews** — Save a task with `publishedAfter` set to the date of your last run (or the newest `published_at` you hold) and schedule it: each run reads the asked view newest first, stops at the first review older than the date, and delivers only the reviews published since. For reviews updated since (an edited review keeps its original date), read the business again without the cutoff.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `business` | `string` | `""` | One business: its domain (`pipedrive.com`) or its Trustpilot review URL on any country host (`https://www.trustpilot.com/review/pipedrive.com`, `https://uk.trustpilot.com/review/pipedrive.com?stars=1&languages=en`: the URL's own filters apply). Not read when `businesses` has an item: the list is then the whole run, and the filters here are its defaults. |
| `businesses` | `array` | `[]` | Many businesses in one run: a list of domains or Trustpilot review URLs as strings, or objects with their own filters and your own id: `{"business": "pipedrive.com", "language": "en", "stars": "1,2", "dateRange": "last12months", "publishedAfter": "2026-09-01", "verifiedOnly": false, "withRepliesOnly": false, "topics": ["customer_service"], "keyword": "refund", "sort": "recency", "maxReviewsPerBusiness": 500, "id": "my-ref-17"}` (the run's fields are the defaults). Up to 500 a run; a value that is no business is a free `invalid` row, and a business given twice with the same filters a free `duplicate` row. |
| `maxReviewsPerBusiness` | `integer` | `0` | Stop a business after this many review rows. 0 = every review reachable logged out: the asked view's 200 newest (Trustpilot serves 10 pages of 20 a view), then the slices past the cap (languages, stars, topics, keywords learned from the reviews read), every review once. The free business row says how many Trustpilot counts in the asked view and whether the walk was COMPLETE, TRUNCATED or CAPPED. Up to 200 the rows are the newest in the asked order (`rank` 1 to 200). |
| `language` | `string` | `"all"` | `all` (the default: every language the business has reviews in) or one language code as Trustpilot's language filter uses it (`en`, `de`, `fr`, `pt-BR`). One language per view: list several businesses with their own `language` for several. A code Trustpilot does not know (it would answer with every language) gives a free `invalid` row that lists the business's languages. |
| `stars` | `string` | `""` | Keep reviews of these star ratings only, comma-separated (`1`, `1,2`, `4,5`). Empty = every rating. Applied by Trustpilot; each row's `rating` is the review's own. |
| `dateRange` | \`\` / `last30days` / `last3months` / `last6months` / `last12months` | `""` | Keep reviews published in Trustpilot's own date window. Empty = any date. For an exact cutoff use `publishedAfter`. |
| `publishedAfter` | `string` | `""` | Keep reviews published after this date or datetime (`2026-09-01`, `2026-09-01T12:00:00Z`, `2026-09-01T14:00:00+02:00`; no offset = UTC): the walk reads each view newest first and stops at the first review at or before it, so a scheduled run given the newest `published_at` of its last run delivers only what is new. Needs `sort` recency. |
| `verifiedOnly` | `boolean` | `false` | Keep the reviews Trustpilot's own verified filter keeps (verification level `verified`, such as a verified purchase; invited reviews that are not verified are not in it). Applied by Trustpilot. |
| `withRepliesOnly` | `boolean` | `false` | Keep reviews the business replied to. Applied by Trustpilot. |
| `topics` | `array` | `[]` | Keep reviews Trustpilot tags with these topics (several = all of them at once, as the page does): `user_experience`, `customer_service`, `service`, `delivery_service`, `price`, `refund`, `website`, `app`, `payment`, `staff`, `quality`, `order`, `subscription`, `cancellation`, `product`, `value_for_money`, `warranty`, `response_time`, `location`, `return_policy`, `delivery`, `privacy`, `software`, `billing`, `experience`. Empty = every review. |
| `keyword` | `string` | `""` | Keep reviews whose text matches this word or phrase (Trustpilot's own review search). Empty = every review. |
| `sort` | `recency` / `relevance` | `"recency"` | The page's order: `recency` (newest first, the default; `rank` 1 to 200 are the newest) or `relevance` (Trustpilot's own ranking of the same 200). A view holds 200 reviews either way; the slices past them read in recency order. |
| `includeReviews` | `boolean` | `true` | On (the default): the review rows and a free business row per business. Off: one business row per business only (TrustScore, stars, counts, the star and language split, categories, the contact block, the reply behaviour, Trustpilot's AI summary and topic summaries, similar businesses), charged as a `business` row. |
| `includeTransparency` | `boolean` | `false` | One more call per business: Trustpilot's transparency page into the business row's `transparency` column (how the reviews were collected, the monthly counts per star over 12 months, the reports and their outcomes, the reply rate). No extra charge. |
| `maxItems` | `integer` | `0` | Stop the run after this many review rows across every business (0 = no limit; `maxReviewsPerBusiness` caps each business). Business rows are free and not counted. A business left unread at the cap gets a free `not_read` row. |
| `proxyUrl` | `string` |  | Empty (recommended): Trustpilot is read through the Actor's own exits at no extra cost to you. Your own proxy URL (scheme://user:pass@host:port) carries the browser and every call instead. The word none runs without any proxy, from the Apify worker's own IP (for tests). |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A business Trustpilot lists no review for in the asked view is not an error: it gets one free `business` row with `status` empty and the reason, and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**How many reviews does a business return?**

As many as you ask (`maxReviewsPerBusiness`), up to every review reachable logged out. Trustpilot serves 10 pages of 20 per view and sends page 11 to its login; the Actor reads the view, then every language, star, topic and keyword slice of it, each review once. On our runs: 6,074 of www.grammarly.com's 10,400 reviews in 15.6 minutes (767 calls, every slice; the run cost about $2.59 at Starter prices); a 905-review one-star English view 767 of 905; a 230-review star view whole. The rest sits behind Trustpilot's login, and the business row says exactly how many of Trustpilot's count were read (`verdict` TRUNCATED with the numbers). A whole business of about 10,000 reviews takes 15 to 20 minutes: keep the run's timeout at the default 3,600 s, and raise it for several such businesses in one run (a business the time limit leaves gets a free `not_read` row). Nobody reaches every review of a very large business without a Trustpilot login or its app's private token; this Actor uses neither.

**Are the rows the newest first?**

Under `sort` recency the asked view's 200 newest come first in Trustpilot's order (`rank` 1 to 200). Reviews read past the cap through the slices come in each slice's own newest-first order, so sort the dataset by `published_at` for one newest-first list across everything.

**Which status is which?**

A business row's `status` is `ok` (reviews served, or the summary in a summary-only run), `empty` (Trustpilot lists no review in the asked view), `not_found` (Trustpilot has no page for the domain), `failed` (a refusal or an error; free), `invalid` (a value that is no domain or Trustpilot review URL), `duplicate` (the same business and filters given twice: read once), or `not_read` (left at `maxItems`, the charge limit or the run's time limit). A review row's `status` is `ok`.

**Is the reviewer's name on the row?**

The reviewer's display name, country, review count, consumer id and avatar URL are on every review row as Trustpilot shows them publicly. They are personal data: process them under your own lawful basis.

**Does it need a Trustpilot account or API key?**

No. Everything is read from the public review pages, logged out, and nothing of yours is sent to Trustpilot. Trustpilot's Business API and its app's private endpoints are not used.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/trustpilot-reviews-scraper').call({"business": "pipedrive.com", "maxReviewsPerBusiness": 100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/trustpilot-reviews-scraper').call(run_input={'business': 'pipedrive.com', 'maxReviewsPerBusiness': 100})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/trustpilot-reviews-scraper --input '{"business": "pipedrive.com", "maxReviewsPerBusiness": 100}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~trustpilot-reviews-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"business": "pipedrive.com", "maxReviewsPerBusiness": 100}'
```

### Support

apify@hyperbach.com

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

## `business` (type: `string`):

One business: its domain (`pipedrive.com`) or its Trustpilot review URL on any country host (`https://www.trustpilot.com/review/pipedrive.com`, `https://uk.trustpilot.com/review/pipedrive.com?stars=1&languages=en`: the URL's own filters apply). Not read when `businesses` has an item: the list is then the whole run, and the filters here are its defaults.

## `businesses` (type: `array`):

Many businesses in one run: a list of domains or Trustpilot review URLs as strings, or objects with their own filters and your own id: `{"business": "pipedrive.com", "language": "en", "stars": "1,2", "dateRange": "last12months", "publishedAfter": "2026-09-01", "verifiedOnly": false, "withRepliesOnly": false, "topics": ["customer_service"], "keyword": "refund", "sort": "recency", "maxReviewsPerBusiness": 500, "id": "my-ref-17"}` (the run's fields are the defaults). Up to 500 a run; a value that is no business is a free `invalid` row, and a business given twice with the same filters a free `duplicate` row.

## `maxReviewsPerBusiness` (type: `integer`):

Stop a business after this many review rows. 0 = every review reachable logged out: the asked view's 200 newest (Trustpilot serves 10 pages of 20 a view), then the slices past the cap (languages, stars, topics, keywords learned from the reviews read), every review once. The free business row says how many Trustpilot counts in the asked view and whether the walk was COMPLETE, TRUNCATED or CAPPED. Up to 200 the rows are the newest in the asked order (`rank` 1 to 200).

## `language` (type: `string`):

`all` (the default: every language the business has reviews in) or one language code as Trustpilot's language filter uses it (`en`, `de`, `fr`, `pt-BR`). One language per view: list several businesses with their own `language` for several. A code Trustpilot does not know (it would answer with every language) gives a free `invalid` row that lists the business's languages.

## `stars` (type: `string`):

Keep reviews of these star ratings only, comma-separated (`1`, `1,2`, `4,5`). Empty = every rating. Applied by Trustpilot; each row's `rating` is the review's own.

## `dateRange` (type: `string`):

Keep reviews published in Trustpilot's own date window. Empty = any date. For an exact cutoff use `publishedAfter`.

## `publishedAfter` (type: `string`):

Keep reviews published after this date or datetime (`2026-09-01`, `2026-09-01T12:00:00Z`, `2026-09-01T14:00:00+02:00`; no offset = UTC): the walk reads each view newest first and stops at the first review at or before it, so a scheduled run given the newest `published_at` of its last run delivers only what is new. Needs `sort` recency.

## `verifiedOnly` (type: `boolean`):

Keep the reviews Trustpilot's own verified filter keeps (verification level `verified`, such as a verified purchase; invited reviews that are not verified are not in it). Applied by Trustpilot.

## `withRepliesOnly` (type: `boolean`):

Keep reviews the business replied to. Applied by Trustpilot.

## `topics` (type: `array`):

Keep reviews Trustpilot tags with these topics (several = all of them at once, as the page does): `user_experience`, `customer_service`, `service`, `delivery_service`, `price`, `refund`, `website`, `app`, `payment`, `staff`, `quality`, `order`, `subscription`, `cancellation`, `product`, `value_for_money`, `warranty`, `response_time`, `location`, `return_policy`, `delivery`, `privacy`, `software`, `billing`, `experience`. Empty = every review.

## `keyword` (type: `string`):

Keep reviews whose text matches this word or phrase (Trustpilot's own review search). Empty = every review.

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

The page's order: `recency` (newest first, the default; `rank` 1 to 200 are the newest) or `relevance` (Trustpilot's own ranking of the same 200). A view holds 200 reviews either way; the slices past them read in recency order.

## `includeReviews` (type: `boolean`):

On (the default): the review rows and a free business row per business. Off: one business row per business only (TrustScore, stars, counts, the star and language split, categories, the contact block, the reply behaviour, Trustpilot's AI summary and topic summaries, similar businesses), charged as a `business` row.

## `includeTransparency` (type: `boolean`):

One more call per business: Trustpilot's transparency page into the business row's `transparency` column (how the reviews were collected, the monthly counts per star over 12 months, the reports and their outcomes, the reply rate). No extra charge.

## `maxItems` (type: `integer`):

Stop the run after this many review rows across every business (0 = no limit; `maxReviewsPerBusiness` caps each business). Business rows are free and not counted. A business left unread at the cap gets a free `not_read` row.

## `proxyUrl` (type: `string`):

Empty (recommended): Trustpilot is read through the Actor's own exits at no extra cost to you. Your own proxy URL (scheme://user:pass@host:port) carries the browser and every call instead. The word none runs without any proxy, from the Apify worker's own IP (for tests).

## Actor input object example

```json
{
  "business": "pipedrive.com",
  "businesses": [],
  "maxReviewsPerBusiness": 100,
  "language": "all",
  "stars": "",
  "dateRange": "",
  "publishedAfter": "",
  "verifiedOnly": false,
  "withRepliesOnly": false,
  "topics": [],
  "keyword": "",
  "sort": "recency",
  "includeReviews": true,
  "includeTransparency": false,
  "maxItems": 0
}
```

# Actor output Schema

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

All scraped records in the default dataset. One row per review (and one free summary row per business):

## `runSummary` (type: `string`):

How the run went: review rows charged, business rows charged (summary-only runs), free rows, businesses by status, the walk per business (Trustpilot's count, reviews found and delivered, views and calls, the verdict), the token server (browser loads, refreshes, reloads), the source counters (calls, served, refused, exits, rotations, bytes) and the memory watch.

# 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 = {
    "business": "pipedrive.com",
    "maxReviewsPerBusiness": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/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 = {
    "business": "pipedrive.com",
    "maxReviewsPerBusiness": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/trustpilot-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "business": "pipedrive.com",
  "maxReviewsPerBusiness": 100
}' |
apify call hyperbach/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hyperbach/trustpilot-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tOyC4lO7G4Hi3KScd/builds/g3CoGzkiqzLQj56gI/openapi.json