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

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

Every review reachable of a business, with the transparency page

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

Only the reviews since a date (a scheduled task)

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

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

{
  "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:

{
  "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

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

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

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

REST

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.