Building a Review Monitoring Pipeline: Trustpilot Business Search to Reviews in One Workflow

Most Trustpilot monitoring requests start the same way: “pull reviews for every company in this space.” The problem is that “every company in this space” isn’t a list you already have — you have to discover it first. That’s a two-step job: find the companies, then pull their reviews. Doing it manually means searching Trustpilot’s category pages by hand, copying domains into a spreadsheet, then running a separate review pull for each one.

The Trustpilot Business Search Scraper and the Trustpilot Reviews Scraper are built specifically to chain together — they share a domain key by design. This post walks through the actual pipeline: search a category, take the domain field from every result, and feed it straight into the Reviews Scraper.

Why Chain Instead of Scraping Reviews Directly

The Reviews Scraper needs a companyDomain as input — it doesn’t discover companies on its own, it pulls reviews for a domain you already know. If your job is “monitor everyone in fintech” rather than “monitor this one company,” you need a discovery step first. Business Search is that discovery step: it browses a category or keyword and returns a list of companies with their domain, trustScore, reviewsCount and verification status. You decide which of those companies are worth pulling full reviews for, and pass their domains downstream.

This also controls cost. Business Search is $2 per 1,000 businesses; Reviews is $5 per 1,000 reviews. Discovering 200 businesses costs $0.40. Blindly pulling 100 reviews for all 200 of them costs $10, whether or not most of those companies turn out to be irrelevant. Filtering the discovery results first — by TrustScore, review volume, or verification status — before triggering the Reviews run is the difference between a targeted pipeline and burning budget on companies you didn’t need.

The Pipeline

Step 1: Search a category

import os
from apify_client import ApifyClient

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

search_run = apify.actor("themineworks/trustpilot-business-search").call(run_input={
    "query": "electronics_technology",
    "searchMode": "category",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
})

businesses = list(apify.dataset(search_run["defaultDatasetId"]).iterate_items())
print(f"Found {len(businesses)} businesses")

Step 2: Filter to the companies worth monitoring

# Only pull reviews for verified, claimed businesses with meaningful review volume
targets = [
    b for b in businesses
    if b.get("domain")
    and b.get("isVerified")
    and b.get("reviewsCount", 0) >= 100
]
print(f"{len(targets)} businesses qualify for review monitoring")

Step 3: Chain each domain into the Reviews Scraper

all_reviews = []

for business in targets:
    reviews_run = apify.actor("themineworks/trustpilot-reviews").call(run_input={
        "companyDomain": business["domain"],
        "maxResults": 100,
    })

    reviews = list(apify.dataset(reviews_run["defaultDatasetId"]).iterate_items())
    for r in reviews:
        r["source_business_name"] = business["name"]
        r["source_trust_score"] = business.get("trustScore")

    all_reviews.extend(reviews)
    print(f"  {business['domain']}: {len(reviews)} reviews pulled")

print(f"Total reviews collected across {len(targets)} businesses: {len(all_reviews)}")

Step 4: Surface what needs attention

The Reviews Scraper returns rating, text, review_date and reply_text per review. Unanswered negative reviews are the highest-priority signal in a monitoring pipeline — a business with a low rating and no reply_text has a live reputation problem it hasn’t responded to:

unanswered_negative = [
    r for r in all_reviews
    if r.get("rating", 5) <= 2 and not r.get("reply_text")
]

for r in unanswered_negative[:10]:
    print(f"[{r['source_business_name']}] {r['rating']}★ — {r['title']}")
    print(f"  {r['text'][:120]}...")

Running It on a Schedule

A one-time pull tells you where things stand today. The value of this pipeline compounds when it runs on a schedule — daily or weekly — and you diff against the previous run to catch new reviews as they land, rather than re-reading everything each time:

import json
from datetime import datetime

# Load domains + last-seen review IDs from a previous run
try:
    with open("seen_review_ids.json") as f:
        seen_ids = set(json.load(f))
except FileNotFoundError:
    seen_ids = set()

new_reviews = [r for r in all_reviews if r["review_id"] not in seen_ids]
print(f"{len(new_reviews)} new reviews since last run")

seen_ids.update(r["review_id"] for r in all_reviews)
with open("seen_review_ids.json", "w") as f:
    json.dump(list(seen_ids), f)

Wire this into a cron job or an Apify scheduled task, and route new_reviews (especially the unanswered negative ones) to Slack, email, or a CRM webhook.

Cost of a Realistic Run

Discovering 100 companies in a category and pulling 100 reviews each for the 40 that pass a quality filter:

• Business Search: 100 businesses × $0.002 = $0.20
• Reviews: 40 companies × 100 reviews × $0.005 = $20.00
• Total: ~$20.20 for a full category sweep with review data for every qualified competitor

Re-running weekly to catch new reviews costs the same per sweep, though in practice you’d lower maxResults on the Reviews step for repeat runs since you’re mostly catching new activity, not re-pulling the full history each time.

Related Reading

For the discovery step in isolation, see Trustpilot Business Search: Discover Companies by Category with TrustScore Data. For a broader look at reputation monitoring patterns across review platforms, see automated reputation monitoring with Trustpilot. Both actors — Trustpilot Business Search and Trustpilot Reviews — are also exposed as MCP tools, so an AI agent can run this same discovery-then-monitor logic conversationally for smaller one-off checks.