# TrustRadius Reviews Scraper (`khadinakbar/trustradius-reviews-scraper`) Actor

Scrape TrustRadius B2B software reviews: ratings (0–10), pros/cons, firmographics, feature scores. Product URL, slug, or search. HTTP-first with Residential + Firefox fallback. MCP-ready.

- **URL**: https://apify.com/khadinakbar/trustradius-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 review scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## TrustRadius Reviews Scraper

For SaaS competitive analysts, product marketers, and MCP agents who need structured B2B review evidence. This Actor extracts public TrustRadius software reviews into flat dataset rows with native TrustRadius scores (zero to ten), titles, bodies, best-effort pros/cons, and reviewer firmographics when the public page exposes them. Provide a product URL, product slug, or search query — then download JSON/CSV/Excel or pull rows via the Apify API.

### Focused standalone workflow

This Actor is a focused standalone TrustRadius workflow. An analyst pastes a Slack product reviews URL, keeps Apify Residential US on, caps `maxReviewsPerProduct` at a small number for a smoke test, then exports review rows into a competitor matrix. For multi-platform review aggregation across G2/Capterra/TrustRadius after the TrustRadius shortlist, use [software-reviews-all-in-one-scraper](https://apify.com/khadinakbar/software-reviews-all-in-one-scraper). For Capterra-only depth, use [capterra-reviews-scraper](https://apify.com/khadinakbar/capterra-reviews-scraper).

### Best fit

Choose this Actor when you already know a TrustRadius product URL or slug and need native TrustRadius scores plus public review text for competitive research or agent pipelines.

It works well for bounded product deep-dives and search-to-reviews discovery. Pair it with [software-reviews-all-in-one-scraper](https://apify.com/khadinakbar/software-reviews-all-in-one-scraper) when the next step is a cross-platform corpus rather than TrustRadius alone.

### Practical scenario

A competitive analyst pastes the Slack TrustRadius reviews URL, sets `maxReviewsPerProduct` to `10`, and leaves Residential US as the default proxy. The run returns review rows with `rating`, `reviewTitle`, `reviewBody`, and optional firmographics. Next they filter `starRating` to high-score bands and feed themes into a battlecard.

### Best results

- Prefer exact product URLs or known slugs over broad search when you need depth on one product.
- Keep Apify Residential US enabled; bare IPs commonly hit Cloudflare challenges.
- TrustRadius scores use a native zero-to-ten scale — use `ratingOutOf5` only as a convenience helper for classic five-star style filters.
- Start with `maxReviewsPerProduct: 1` to confirm the slug, then raise the cap for production batches.
- When Cloudflare challenges every path and zero rows are saved, the Actor records `UPSTREAM_FAILED` with an honest upstream outcome instead of empty billed rows.

### Quick start input

```json
{
  "startUrls": [
    { "url": "https://www.trustradius.com/products/slack/reviews" }
  ],
  "maxReviewsPerProduct": 10,
  "sortReviewsBy": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

Slug mode:

```json
{
  "productSlugs": ["notion"],
  "maxReviewsPerProduct": 5
}
```

Search mode:

```json
{
  "searchQuery": "Slack",
  "maxProductsPerSearch": 1,
  "maxReviewsPerProduct": 3,
  "includeReviews": true
}
```

### Input reference

| Field | Type | What it controls |
|---|---|---|
| `startUrls` | array | TrustRadius product/reviews URLs (normalized to `/products/{slug}/reviews`). |
| `productSlugs` | array | Slugs without a full URL (for example `slack`, `notion`). |
| `searchQuery` | string | Product name search, then scrape matched products. |
| `maxReviewsPerProduct` | integer | Cap per product (default 50, prefill 1). |
| `maxProductsPerSearch` | integer | Cap on search matches (default 5). |
| `includeReviews` | boolean | Search mode: scrape reviews (default) vs product cards only. |
| `includeProductSummary` | boolean | Emit a product card when reviews are off. |
| `sortReviewsBy` | enum | `newest` or `helpful`. |
| `starRating` | array | Market-style 1–5★ bands mapped onto TrustRadius 0–10. |
| `companySize` | array | `small` / `medium` / `large` when firmographics exist. |
| `proxyConfiguration` | object | Prefer Apify Residential US; Unblocker is used automatically as a separate recovery path when Residential yields zero reviews. |

### Output data

| Field | Description |
|---|---|
| `recordType` | `review` or `product` |
| `productName` / `productSlug` / `productUrl` | Product context |
| `rating` | Native TrustRadius score (zero to ten) |
| `ratingOutOf5` | Derived half-scale helper |
| `reviewTitle` / `reviewBody` | Public review text |
| `pros` / `cons` | When the HTML card exposes them |
| `reviewer` | name, title, company, size, industry when public |
| `reviewDate` / `reviewUrl` | Provenance |
| `scrapedAt` | ISO 8601 timestamp |

Example review row:

```json
{
  "platform": "trustradius",
  "recordType": "review",
  "productName": "Slack",
  "productSlug": "slack",
  "productUrl": "https://www.trustradius.com/products/slack/reviews",
  "rating": 9,
  "ratingOutOf5": 4.5,
  "reviewTitle": "Essential for remote collaboration",
  "reviewBody": "Channels keep our distributed team organized...",
  "pros": ["Fast search", "Integrations"],
  "cons": ["Notification noise"],
  "reviewer": {
    "name": "Alex R.",
    "title": "IT Manager",
    "companySize": "201-1000",
    "industry": "Software"
  },
  "reviewDate": "2025-11-02T00:00:00.000Z",
  "scrapedAt": "2026-09-22T12:00:00.000Z"
}
```

You can download the dataset as JSON, HTML, CSV, or Excel.

### Pricing

Pay per event + platform usage (`isPPEPlatformUsagePaidByUser: true`). The live Pricing tab is the current source of truth after deployment.

| Event | Price | When charged |
|---|---|---|
| `apify-actor-start` | $0.00005 | Once per run (memory-scaled) |
| `review-scraped` (primary) | $0.005 | Each review row saved |
| `product-found` | $0.01 | Each product card when reviews are not scraped |

Worked cost example for a Slack prefill-style run with one review: `$0.00005 + $0.005 = $0.00505` in named PPE events, plus Residential/browser platform usage. Invalid inputs and truthful empty matches skip `review-scraped` charges; Cloudflare-challenged runs with zero rows likewise skip review events.

### API example

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~trustradius-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url": "https://www.trustradius.com/products/slack/reviews"}],
    "maxReviewsPerProduct": 10,
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "US"
    }
  }'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/trustradius-reviews-scraper').call({
  startUrls: [{ url: 'https://www.trustradius.com/products/slack/reviews' }],
  maxReviewsPerProduct: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### MCP / AI agent

MCP tool name: `apify--trustradius-reviews-scraper`.

> Scrape Slack TrustRadius public reviews with Residential US, return dataset rows, and note COMPLETE vs VALID\_EMPTY vs UPSTREAM\_FAILED.

Agent guidance: prefer `startUrls` / `productSlugs` over broad search; keep Residential US on; page via `maxReviewsPerProduct`; read `OUTPUT`/`RUN_SUMMARY` for outcome and charges. Partial runs keep successful rows and mark `PARTIAL`.

### Outcomes

| Outcome | Meaning |
|---|---|
| `COMPLETE` | Targets produced useful rows |
| `PARTIAL` | Some targets incomplete with warnings |
| `VALID_EMPTY` | Valid targets, no matching public reviews (or filters excluded all) |
| `INVALID_INPUT` | No usable TrustRadius targets |
| `UPSTREAM_FAILED` | Cloudflare/CSR block with zero useful rows |
| `CONFIG_ERROR` | Required proxy/config unavailable |

Every run writes `OUTPUT` and `RUN_SUMMARY` with `itemsPushed` and `chargedEventCounts`.

### Scope and recovery guidance

Provide Residential US for Cloudflare-protected TrustRadius pages. Start with known URLs or slugs, validate one product, then scale caps. When CSR review loading stays empty after retries (including a separate Unblocker recovery attempt), the Actor records `UPSTREAM_FAILED` so operators can adjust proxy settings while keeping the contract honest. Invalid hosts resolve as `INVALID_INPUT` with zero review charges.

### Builder's note

I built this Actor after TrustRadius stopped embedding `review[]` arrays inside SoftwareApplication JSON-LD and moved public reviews behind a client-rendered loader. HTTP-first still wins when the shell is warm, but the reliable path is Playwright Firefox waiting out `ReviewsAll_loading`, scrolling for lazy cards, and capturing review JSON from network responses. In my testing, Slack/Notion/Asana clear Residential consistently, while some high-traffic CRM/video products remain Cloudflare-sensitive — so the runtime records an honest block when aggregate review counts exist but zero cards extract.

### Differentiation

Dedicated TrustRadius depth with native zero-to-ten scores, MCP-ready schemas, PPE + usage pass-through, Residential-first transport plus separate Unblocker recovery, and outcome contracts that refuse hollow soft-success.

### Legal / responsible use

Use only for lawful purposes and respect TrustRadius terms of service and applicable privacy law. Public pages only — no login bypass. Reviewer names and firmographics may appear when TrustRadius shows them publicly; callers need a lawful basis for any personal data use. TrustRadius is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by TrustRadius.

# Actor input Schema

## `startUrls` (type: `array`):

TrustRadius product or reviews URLs to scrape. Each must look like https://www.trustradius.com/products/{slug}/reviews (product root URLs are normalized). Provide this OR productSlugs OR searchQuery.

## `productSlugs` (type: `array`):

TrustRadius product slugs without the full URL, e.g. slack or hubspot. Provide this OR startUrls OR searchQuery.

## `searchQuery` (type: `string`):

Product name or keyword to search on TrustRadius, then scrape matching products. Free text such as Slack or CRM. Provide this OR startUrls OR productSlugs.

## `maxReviewsPerProduct` (type: `integer`):

Upper bound on reviews extracted per product (1-5000). Defaults to 50. Prefill uses 1 for a cheap health check.

## `maxProductsPerSearch` (type: `integer`):

In search mode, how many matching products to take (1-100). Defaults to 5. Ignored for startUrls/productSlugs.

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

When true (default), search mode scrapes reviews for each matched product. When false, search returns product cards only (product-found billing).

## `includeProductSummary` (type: `boolean`):

When true and includeReviews is false, URL/slug mode may emit a product card. Leave false for review-only runs.

## `sortReviewsBy` (type: `string`):

TrustRadius sort before the per-product cap: newest maps to most-recent; helpful maps to most-helpful.

## `starRating` (type: `array`):

Optional market-style 1-5 star filter mapped to TrustRadius 0-10 bands (5 stars approx 8-10). Empty means no filter.

## `companySize` (type: `array`):

Optional reviewer company-size filter: small / medium / large (best-effort from public firmographics).

## `proxyConfiguration` (type: `object`):

Proxy used to reach TrustRadius. Residential is required. Defaults to Apify Residential US.

## `debug` (type: `boolean`):

When true, writes a first-page diagnostic dump to the key-value store. Leave off for normal runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.trustradius.com/products/slack/reviews"
    }
  ],
  "productSlugs": [
    "slack"
  ],
  "searchQuery": "Slack",
  "maxReviewsPerProduct": 1,
  "maxProductsPerSearch": 1,
  "includeReviews": true,
  "includeProductSummary": false,
  "sortReviewsBy": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "debug": false
}
```

# Actor output Schema

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

One row per review (or product card in discovery mode).

## `output` (type: `string`):

Final outcome, itemsPushed, and chargedEventCounts.

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

Diagnostics including blockSignals, filters, and billing counters.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.trustradius.com/products/slack/reviews"
        }
    ],
    "maxReviewsPerProduct": 1,
    "maxProductsPerSearch": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/trustradius-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 = {
    "startUrls": [{ "url": "https://www.trustradius.com/products/slack/reviews" }],
    "maxReviewsPerProduct": 1,
    "maxProductsPerSearch": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/trustradius-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 '{
  "startUrls": [
    {
      "url": "https://www.trustradius.com/products/slack/reviews"
    }
  ],
  "maxReviewsPerProduct": 1,
  "maxProductsPerSearch": 1
}' |
apify call khadinakbar/trustradius-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/trustradius-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/lFAe0OfsgZUuP83kR/builds/3bjsyvWk48CG8Yc22/openapi.json