# TrustRadius Scraper — Reviews, Scores, Pros & Cons (`tortuga/trustradius-scraper`) Actor

TrustRadius software reviews for any product: 1-10 score, headline, pros and cons, use cases, ROI, alternatives considered, feature ratings, reviewer job title, industry, company and company size. Sort by newest, filter by stars or company size. Product profiles and category lists too.

- **URL**: https://apify.com/tortuga/trustradius-scraper.md
- **Developed by:** [Trevor Ortega](https://apify.com/tortuga) (community)
- **Categories:** Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 reviews

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 Scraper: Reviews, Scores, Pros & Cons

Export the TrustRadius reviews of any software product: one row per review with the 1-10 score, headline, pros and cons, use cases, return on investment, alternatives considered, per-feature ratings and who wrote it (name as shown, job title, department, industry, company, company size and LinkedIn link when public). Sort by newest, filter by stars or company size, or keep only reviews newer than a date.

Switch **What to scrape** to `products` for product profiles (trScore, rating distribution, pricing plans, feature scores, alternatives, awards) or to `category` for every product card of a category page. No login, no browser. **$2 per 1,000 reviews**, plus Apify platform usage (mostly residential proxy: about $1 per 1,000 full reviews in our test runs).

**What you get**

- **Review:** headline, 1-10 rating, pros, cons, use cases, likelihood to recommend, ROI, review date, permalink
- **Comparisons:** alternatives considered and why, other software used with ratings, per-feature 1-10 ratings
- **Reviewer:** name as shown (or "Verified User"), job title and level, department, industry, company, company size, country, LinkedIn URL when published
- **Trust signals:** vetted, verified and incentivized flags, review source and quality grade
- **Products and categories** (other modes): trScore, rating distribution, pricing plans, feature scores, alternatives, integrations, awards

**Try it:** the input is prefilled with Slack's reviews and 20 items. Click **Start** and the 20 newest full reviews arrive in about a minute, for about $0.06 including proxy usage.

**Sample output** (one review, trimmed; the full field list and example follow below):

```json
{
  "productName": "Slack",
  "title": "Slack is a productivity hack",
  "overallRating": 10,
  "pros": ["Eliminates the need for more zoom meetings, giving me time back"],
  "cons": ["Notifications can get noisy, especially with so many integrations"],
  "reviewerRole": "Account Manager",
  "reviewerDepartment": "Sales",
  "reviewerIndustry": "Consumer Services",
  "companySize": "51-200 employees",
  "reviewDate": "2026-10-29",
  "url": "https://www.trustradius.com/reviews/slack-2026-10-28-10-29-08-276"
}
```

### What data does TrustRadius Reviews Scraper extract?

**Review items** (`mode: reviews`, default):

| Field | Description |
|---|---|
| `productSlug`, `productName`, `productUrl`, `vendor` | Product the review is about (`slack` in `/products/slack`) and its vendor |
| `reviewId`, `reviewSlug` | Stable review id (`6a72ca49c2147373c7cd803c`) and URL slug |
| `title` | Review headline |
| `overallRating`, `ratingScale` | TrustRadius score on its native 1-10 scale (`ratingScale` is always `10`) |
| `useCasesAndDeployment` | "Use Cases and Deployment Scope" answer |
| `pros`, `cons` | Lists of bullet points |
| `likelihoodToRecommend`, `likelihoodToRecommendText` | 1-10 score (equals the overall score on TrustRadius) and the "where it fits / where it doesn't" text |
| `returnOnInvestment` | ROI bullet points |
| `usabilityRating`, `usabilityText` | 1-10 usability score and explanation |
| `supportRating`, `supportText`, `implementationRating`, `implementationText`, `likelihoodToRenew`, ... | Further 1-10 sliders when the reviewer answered them (`null` otherwise) |
| `alternativesConsidered`, `alternativesText` | Products evaluated and why this one was chosen |
| `otherSoftwareUsed` | `[{productName, rating}]`, other tools the reviewer uses with their 1-10 rating |
| `featureRatings` | `[{feature, group, rating}]`, per-feature 1-10 ratings |
| `keyInsights` | Quick yes/no pulse (`valueprice`, `features`, `salesmarketing`, `implementation`, `buyagain`) |
| `answers` | Every published question and answer of the review as `{section, slug, question, type, answer, followup}`, so nothing is lost |
| `reviewerName` | Reviewer name as shown on the review; `"Verified User"` when the reviewer chose not to be shown publicly (TrustRadius' own label) |
| `reviewerId`, `reviewerUrl` | TrustRadius user id and public profile URL (`https://www.trustradius.com/users/<id>`); `null` for "Verified User" reviews |
| `reviewerLinkedInUrl` | LinkedIn profile URL when the review page links it publicly; `null` otherwise |
| `reviewerRole`, `reviewerJobType`, `reviewerDepartment` | Job title, job level ("Manager", "C-Level Executive"...) and department |
| `reviewerIndustry`, `companyName`, `companySize`, `reviewerCountry` | Industry, company, size band ("51-200 employees") and ISO country code |
| `yearsExperience`, `reviewerRoles` | Years using the product; roles such as `user`, `manager`, `decisionMaker` |
| `reviewDate`, `editedDate` | ISO dates (`2026-08-10`) |
| `grade` | TrustRadius review quality grade (A-D) |
| `isVetted`, `isVerified`, `isLinkedInVerified`, `isTrusted`, `isReseller` | Review vetting / verification flags |
| `isIncentivized`, `incentive`, `source` | Whether a gift card was offered (`TrustRadius`) and how the review was sourced (`CommunityInvite`, `RaaS`, ...) |
| `hasFullReview` | `true` when the review's own page was read (see **Fetch full reviews**) |
| `url`, `listingUrl` | Review permalink and the list page it was found on |

Reviewer identity is exported exactly as the page shows it: a reviewer TrustRadius displays as "Verified User" stays "Verified User", with no id, profile or LinkedIn link. Photos / avatars are not collected.

**Product items** (`mode: products`): `slug`, `name`, `url`, `vendor`, `vendorUrl`, `description`, `longDescription`, `trScore` (1-10), `ratingCount` (all ratings), `reviewCount` (written reviews), `ratingDistribution` (score bands 9-10 / 7-8 / 5-6 / 3-4 / 1-2), `reviewerCompanySizes`, `reviewerDepartments`, `reviewerJobTypes`, `reviewerCountries`, `primaryCategory`, `categories`, `categoryUrls`, `startingPrice`, `startingPriceText`, `startingPricePeriod`, `startingPriceUnit`, `pricing` (plans with `name`, `price`, `priceText`, `period`, `unit`, `notes`), `pricingUrl`, `hasFreePlan`, `features` (per-feature `score`, `ratingCount`, `categoryAverage`), `featureList`, `alternatives` (name, URL, trScore, rating count), `integrations`, `awards` (full history with dates), `currentAwards`, `operatingSystems`, `prosSummary`, `consSummary`, `faq`, `topIndustries`, `isCustomerVerified`, `homepage`, `logoUrl`, `screenshots`.

**Category cards** (`mode: category`): `position`, `category`, `categorySlug`, `categoryUrl`, `slug`, `name`, `url`, `vendor`, `trScore`, `ratingCount`, `reviewCount`, `tagline`, `description`, `startingPrice`, `trialAvailable`, `awards`, `topFeatures`, `prosSummary`, `consSummary`, `homepage`, `pricingUrl`, `logoUrl`.

### How to use TrustRadius Reviews Scraper

1. Paste one or more URLs into **Start URLs**: a product page (`https://www.trustradius.com/products/slack`), its reviews page, a category page (`https://www.trustradius.com/categories/crm`) or a single review (`https://www.trustradius.com/reviews/slack-2026-08-05-00-29-43`).
2. Pick **What to scrape**: reviews (default), product profiles, or category cards.
3. Set **Max items** and, for category runs, **Max reviews per product** so the budget is spread across products.
4. Choose **Sort reviews** (most recent by default), optionally **Only these star ratings** (e.g. `1, 2, 3` for critical reviews) and **Only these company sizes** (`small`, `medium`, `large`).
5. Leave **Fetch full reviews** on for the complete answer set, or turn it off for a fast pass with title, score, use case, pros, cons and reviewer role / company size only.
6. Click **Start**. Results appear in the **Dataset** tab; export as JSON, CSV or Excel, or read them through the API.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.trustradius.com/products/slack/reviews" },
    { "url": "https://www.trustradius.com/categories/crm" }
  ],
  "mode": "reviews",
  "maxItems": 500,
  "maxReviewsPerProduct": 100,
  "sortReviews": "most_recent",
  "ratingFilter": [],
  "companySizeFilter": [],
  "fetchFullReviews": true
}
```

### Output example

```json
{
  "type": "review",
  "productSlug": "slack",
  "productName": "Slack",
  "productUrl": "https://www.trustradius.com/products/slack",
  "vendor": "Salesforce",
  "reviewId": "6a72ca49c2147373c7cd803c",
  "title": "Well Organized and Easy to Manage",
  "overallRating": 9,
  "ratingScale": 10,
  "useCasesAndDeployment": "My team uses Slack every day for communication between developer, tester, manager, QA...",
  "pros": ["Keep project discussions organized with separate channels.", "Quick direct messages help solve small issues without long meetings."],
  "cons": ["Too many notification can be distracting, even with notifications setting."],
  "likelihoodToRecommend": 9,
  "likelihoodToRecommendText": "Slack works very well for daily team communications, project discussions, bug tracking...",
  "returnOnInvestment": ["Faster communication between team members.", "Reduced the need for long email conversations"],
  "usabilityRating": 9,
  "alternativesConsidered": ["Microsoft Teams"],
  "alternativesText": "Before using Slack, I worked with Microsoft Teams. ... I found Slack easier for day-to-day communication.",
  "otherSoftwareUsed": [{ "productName": "Microsoft Teams", "rating": 9 }, { "productName": "Google Workspace", "rating": 8 }],
  "featureRatings": [{ "feature": "Chat", "group": "Communication", "rating": 10 }, { "feature": "Search", "group": "Project Management", "rating": 9 }],
  "keyInsights": { "valueprice": "yes", "features": "yes", "salesmarketing": "yes", "implementation": "yes", "buyagain": "yes" },
  "reviewerName": "Rushikesh Vasande",
  "reviewerId": "6a708ce532f254acc155f958",
  "reviewerUrl": "https://www.trustradius.com/users/6a708ce532f254acc155f958",
  "reviewerLinkedInUrl": null,
  "reviewerRole": "Full-stack developer",
  "reviewerJobType": "Professional",
  "reviewerDepartment": "Information Technology",
  "reviewerIndustry": "Computer Software",
  "companySize": "501-1000 employees",
  "reviewerCountry": "IND",
  "yearsExperience": 4,
  "reviewDate": "2026-08-10",
  "grade": "B",
  "isVetted": true,
  "isIncentivized": false,
  "source": "CommunityInvite",
  "hasFullReview": true,
  "url": "https://www.trustradius.com/reviews/slack-2026-08-05-00-29-43"
}
```

### How much does it cost?

Pay per item: $0.002 per review, $0.004 per product profile (two page fetches), $0.001 per category card, plus normal Apify platform usage. No start fee, no subscription. 1,000 full reviews cost $2 in item fees plus platform usage. With **Fetch full reviews** on, each review is one extra ~1 MB page fetch, and because TrustRadius blocks datacenter IPs the default proxy is residential, so that bandwidth is the main usage cost: our 20-review test runs used $0.020-0.024 of platform usage, about $1-1.20 per 1,000 full reviews. Turn **Fetch full reviews** off when the list-page fields are enough; then each list page of 10 reviews is a single request.

### How do I scrape all reviews of a product?

Use the product's reviews URL and raise **Max items** and **Max reviews per product**. TrustRadius lists 10 written reviews per page; the actor walks every page (Slack has 640+ written reviews on 65 pages). Sorting by **most recent** and scheduling the actor weekly is the cheapest way to keep a review feed up to date; deduplicate on `reviewId`.

### What is the difference between ratings and reviews?

TrustRadius shows two counts: `ratingCount` includes quick star ratings without text (10,000+ for Slack), `reviewCount` is the number of written reviews you can actually scrape (640+ for Slack). The score (`trScore`, `overallRating`) is always on a 1-10 scale; the site's star filter maps stars to score bands (5 stars = 9-10, 4 = 7-8, 3 = 5-6, 2 = 3-4, 1 = 1-2), and **Only these star ratings** uses the same mapping.

### Can I get only negative reviews?

Yes. Set **Only these star ratings** to `1, 2, 3` (scores 1-6) and **Sort reviews** to "Lowest rated". Filters are applied by TrustRadius itself, so you do not pay for reviews you do not want. **Only these company sizes** works the same way (`small` = 1-50, `medium` = 51-1,000, `large` = 1,001+ employees).

### Does it work with category pages?

Yes. A category URL such as `https://www.trustradius.com/categories/crm` is paginated automatically (25 products per page, 1,500 products in CRM). In reviews mode every product in the category is opened and up to **Max reviews per product** reviews are saved per product; in products mode each product gets a full profile with pricing plans, feature scores and awards; in category mode you get the ranking cards only, the cheapest way to list a whole category with trScores, review counts and starting prices.

### Monitor changes on a schedule

Turn on **Only new or changed items** and save the input as a task with a Schedule (Apify Console: **Saved tasks** -> **Schedule**, for example daily or weekly). Each run then remembers what earlier runs of the same input returned and outputs only what is new: new reviews in `reviews` mode, products whose trScore, starting price or free plan changed in `products` mode, and category cards whose trScore, starting price or free trial changed in `category` mode. Unchanged items are skipped before they are saved (and before the full-review page is fetched), so they are not charged. Add **Only reviews newer than** (`7 days`, `24 hours` or a date like `2026-10-01`) to bound how far back the first run reads; reviews are then read newest first and paging stops as soon as a page reaches older or already-seen reviews. Monitored items carry `changeType` (`new` or `changed`) and, for changed products and cards, `previousValues` with the old values of the fields that changed (e.g. `{"trScore": 8.9}`); **Monitoring key** keeps several schedules on the same input apart.

### Does it work without login or a browser?

Yes. Everything comes from public pages served to anonymous visitors, read with plain HTTP requests and Chrome TLS fingerprinting. No account, cookies or headless browser, which keeps runs fast (about one second per review with full reviews on, ten reviews per second with it off) and cheap.

### Integrations and API

Use the run in Zapier, Make, n8n, Google Sheets, or call it from Python/Node with the Apify client. See the **API** tab for ready-made snippets. Schedule it to monitor new reviews of your product or your competitors.

### Is it legal to scrape TrustRadius?

This actor collects only data that TrustRadius shows publicly to anonymous visitors: review texts and ratings, reviewer job title, department, industry, company size band and country, product / vendor business information, and the reviewer identity the review displays (name, TrustRadius profile link and, when the page shows it, LinkedIn profile link). Reviewer names and profile links are personal data: if you are subject to GDPR or similar laws, you need a lawful basis to process them. Reviewers shown as "Verified User" keep that label (no name, id or profile link is exported for them), and the actor does not collect photos, email addresses, phone numbers or anything behind a login. You are responsible for how you use the data and for complying with TrustRadius' terms and applicable law.

### Support

Found a bug or need a field added? Open an issue in the **Issues** tab; it is usually answered within a day.

### Related scrapers

- [Clutch Scraper](https://apify.com/tortuga/clutch-scraper): Agency Leads, Rates & Reviews
- [GoodFirms Scraper](https://apify.com/tortuga/goodfirms-scraper): Agencies, Rates & Reviews
- [Trustpilot Scraper](https://apify.com/tortuga/trustpilot-scraper): Reviews, TrustScore & Companies
- [Shopify App Store Scraper](https://apify.com/tortuga/shopify-app-store-scraper): Apps, Pricing, Reviews & Developers
- [Product Hunt Scraper](https://apify.com/tortuga/producthunt-scraper): Launches, Upvotes & Makers

### Found it useful?

A ★ review on this Actor's Apify Store page helps other users find it and tells us what to improve. Issues and feature requests are welcome in the Actor's **Issues** tab.

# Actor input Schema

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

TrustRadius product pages (https://www.trustradius.com/products/slack), review pages (…/products/slack/reviews), category pages (https://www.trustradius.com/categories/crm) or single review pages (https://www.trustradius.com/reviews/slack-2026-08-05-00-29-43). Category pages are paginated automatically and every product on them is processed in the selected mode.

## `mode` (type: `string`):

reviews: one item per user review (default). products: one detailed profile item per product (score, rating distribution, pricing plans, feature scores, alternatives, awards…). category: one card per product on category pages (name, trScore, review count, tagline, starting price, top features).

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

Stop after this many items in total (reviews, products or cards across all start URLs). Keeps cost predictable.

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

Reviews mode only: cap per product, so a category run spreads the budget across products instead of spending it all on the first one.

## `fetchFullReviews` (type: `boolean`):

Open every review's own page to add return on investment, alternatives considered, other software used, usability / support / implementation ratings, per-feature ratings, key insights and reviewer country (one extra ~1 MB request per review). Turn off for a fast, cheap pass with title, score, use case, pros, cons, recommendation text and reviewer role / industry / company size only.

## `sortReviews` (type: `string`):

Order in which reviews are collected (matters when a cap is set). most_recent is best for monitoring.

## `ratingFilter` (type: `array`):

Optional: keep only reviews in these star bands (TrustRadius maps its 1-10 score to 5 stars: 1 = score 1-2, 2 = 3-4, 3 = 5-6, 4 = 7-8, 5 = 9-10). E.g. \[1, 2, 3] for critical reviews. Leave empty for all.

## `companySizeFilter` (type: `array`):

Optional: keep only reviews from small (1-50 employees), medium (51-1,000) or large (1,001+) companies. Leave empty for all.

## `reviewsNewerThan` (type: `string`):

Only reviews newer than: a date (YYYY-MM-DD) or a period such as '7 days' or '24 hours'. TrustRadius shows review dates as days, so a review from the cutoff day itself is kept. Reviews are then read newest first and paging stops at the first page that ends with an older review, so a daily run reads one reviews page per product. Leave empty for no date limit. `reviews` mode only.

## `onlyNewOrChanged` (type: `boolean`):

Remember what earlier runs of this input returned and output only new items: new reviews in `reviews` mode (read newest first; paging stops where the previous run's reviews begin, and full-review pages are fetched for new reviews only), products whose TrustRadius score, starting price or free-plan flag changed in `products` mode, category cards whose score, starting price or free-trial flag changed in `category` mode. Use with a Schedule; unchanged items are not charged. With category start URLs, **Max items** then caps how many items are checked, so every run looks at the same top of the category.

## `monitoringKey` (type: `string`):

Name for this watch, so several schedules on the same search stay separate; defaults to a key derived from the search input. Only used with **Only new or changed items**.

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

TrustRadius blocks datacenter IPs, so residential Apify Proxy is the default. Proxy usage is billed to your account.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.trustradius.com/products/slack/reviews"
    }
  ],
  "mode": "reviews",
  "maxItems": 20,
  "maxReviewsPerProduct": 100,
  "fetchFullReviews": true,
  "sortReviews": "most_recent",
  "ratingFilter": [],
  "companySizeFilter": [],
  "onlyNewOrChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

# 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"
        }
    ],
    "maxItems": 20,
    "ratingFilter": [],
    "companySizeFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tortuga/trustradius-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" }],
    "maxItems": 20,
    "ratingFilter": [],
    "companySizeFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tortuga/trustradius-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"
    }
  ],
  "maxItems": 20,
  "ratingFilter": [],
  "companySizeFilter": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call tortuga/trustradius-scraper --silent --output-dataset

```

## MCP server setup

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