Automated Reputation Monitoring: Schedule Trustpilot Scans and Get Alerted to New Reviews

Checking Trustpilot manually does not scale past a handful of accounts. A reputation-management or customer-success team watching even three or four brands ends up refreshing the same pages every morning, hoping nothing landed overnight that needed a same-day reply. By the time a 1-star review with a viral complaint gets noticed, it has often already sat unanswered for a day.

The fix is not a person checking more often. It is a scheduled scrape that runs on its own, diffs against what it already has, and only surfaces what’s new.

Why Trustpilot Is Hard to Automate Yourself

Trustpilot fronts every page with an AWS WAF “Verifying your connection” JavaScript challenge that fingerprints plain HTTP requests and blocks them outright. A requests.get() call or a basic curl gets nothing back — no reviews, no rating, just a challenge page. Anything that reliably reads Trustpilot needs a real browser session that can clear that challenge, which is exactly what the Trustpilot Reviews Scraper does: a Playwright-driven Chromium instance routed through residential proxies, reading data straight out of Trustpilot’s server-rendered __NEXT_DATA__ JSON. No login, no cookies, no API key required on your side.

Given a company domain — amazon.com, booking.com, whatever you’re tracking — it returns every review it can reach: reviewer name, star rating, title, full review text, publish date, the company’s official reply (if any), review URL, and review ID, plus one business-level record with the overall TrustScore and total review count.

Step 1: Run It Once to Establish a Baseline

Before scheduling anything, pull the current state so you have something to diff against on the next run.

import os, json
from apify_client import ApifyClient

apify = ApifyClient(os.environ["APIFY_TOKEN"])

run = apify.actor("themineworks/trustpilot-reviews").call(run_input={
    "companyDomain": "your-brand.com",
    "maxResults": 200,
    "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
})

reviews = [r for r in apify.dataset(run["defaultDatasetId"]).iterate_items()
           if "review_id" in r]

known_ids = {r["review_id"] for r in reviews}
with open("known_review_ids.json", "w") as f:
    json.dump(list(known_ids), f)

print(f"Baseline: {len(known_ids)} reviews on record.")

Step 2: Schedule It on Apify

Apify’s built-in Scheduler runs an actor on a cron expression without you maintaining a server or a cron job of your own. In the Apify Console, open the actor, go to Schedules, and set a cron like 0 8 * * * for a daily 8am run — or 0 */4 * * * for every four hours if you need faster detection on a high-traffic brand.

Set the same companyDomain and a maxResults high enough to comfortably cover a day’s worth of new reviews (100–200 is plenty for most SMB and mid-market brands; a high-volume consumer brand may need more). You can also pass starsFilter: ["1", "2"] in the schedule’s input if the only reviews you actually want alerted on are negative ones — this cuts noise and cost at the source.

Step 3: Diff Against Known Reviews and Alert

The scheduled run itself doesn’t know what’s “new” — that logic lives in whatever consumes the dataset after each run. A simple version: keep a running set of review_id values you’ve already seen, and only act on the ones that aren’t in it yet.

import os, json, requests
from apify_client import ApifyClient

apify = ApifyClient(os.environ["APIFY_TOKEN"])
SLACK_WEBHOOK = os.environ["SLACK_WEBHOOK_URL"]

with open("known_review_ids.json") as f:
    known_ids = set(json.load(f))

# Fetch the dataset from the most recent scheduled run
run = apify.actor("themineworks/trustpilot-reviews").last_run().get()
reviews = [r for r in apify.dataset(run["defaultDatasetId"]).iterate_items()
           if "review_id" in r]

new_reviews = [r for r in reviews if r["review_id"] not in known_ids]

for r in new_reviews:
    flag = "🔴" if r["rating"] <= 2 else "🟢"
    replied = "already replied" if r.get("reply_text") else "no reply yet"
    requests.post(SLACK_WEBHOOK, json={
        "text": f"{flag} New Trustpilot review ({r['rating']}★, {replied}): "
                f"\"{r['title']}\" — {r['text'][:200]}\n{r['review_url']}"
    })

known_ids.update(r["review_id"] for r in reviews)
with open("known_review_ids.json", "w") as f:
    json.dump(list(known_ids), f)

print(f"{len(new_reviews)} new reviews found and alerted.")

Run this diff-and-alert script as a follow-up step to the scheduled actor run — either as its own scheduled job offset an hour later, or triggered from an Apify webhook that fires when the actor run succeeds. Either way, the loop is: scheduled scrape → diff against known IDs → alert on what’s new → update the known set.

Monitoring Your Own Brand vs. Competitors

The same pipeline works for two different jobs with one input change.

Your own brand. Schedule a scan every few hours, filter to starsFilter: ["1", "2"], and route alerts to whichever channel your CX team actually watches. The reply_text field tells you immediately whether a negative review already has a business reply — an empty reply_text on a 1-star review is your queue of unanswered complaints, sorted by recency.

Competitors. Run the same scan against a competitor’s domain on a slower cadence — daily or weekly is usually enough — without the star filter, since you want the full sentiment picture, not just complaints. Track their TrustScore and total_reviews (from the business-level record) over time to see whether their satisfaction is trending up or down, and mine their review text for the specific complaints and praise showing up repeatedly. That’s product-gap and messaging intelligence you can act on directly.

What This Costs

Pricing is pay-per-event at $5 per 1,000 reviews ($0.005 each). A daily scan capped at 100 results per run costs about $0.50/day, or roughly $15/month, to monitor one brand continuously. Missing domains, blocked pages, and failures are never charged, so a bad run doesn’t cost you anything.

For most SMB and mid-market reputation-monitoring use cases, that’s a fraction of what a dedicated reputation-management SaaS subscription costs — and you own the pipeline, the alert logic, and the data.

Building the Domain List First

If you’re monitoring more than one or two companies — a competitor set, or a portfolio of client accounts at an agency — you need a list of Trustpilot domains before you can schedule anything. Read our guide on finding Trustpilot businesses by category or keyword to pull that list programmatically, then feed the resulting domains into the scheduled scan above.

For the full mechanics of pulling review data itself — pagination, rate limits, and structuring the output for a database — see the Trustpilot review monitoring pipeline guide, which this use case builds on.

Frequently Asked Questions

How fast will I know about a new review?

As fast as your schedule interval. A 4-hour cron catches new reviews within 4 hours of publication; daily catches them within 24. For a brand where response time matters (travel, hospitality, anything with an active support team on social), the 4-hour cadence is worth the extra few dollars a month.

Can I monitor multiple brands with one schedule?

Run the actor once per domain — Trustpilot data is keyed by company, and the actor’s companyDomain input takes a single domain per run. For a portfolio of brands, either schedule the actor multiple times (once per domain) or loop over your domain list in the script that triggers each run via the Apify API.

What if a review gets deleted or edited after I’ve alerted on it?

The diff logic above only tracks additions by review_id. If you need edit-detection too, store the full review record (not just the ID) and compare text and rating on subsequent runs, not just presence.

Do I need a Trustpilot account to do any of this?

No. The actor reads publicly visible review pages with no login, cookies, or API key required.