# TrustRadius Review Scraper ⭐ (`shahidirfan/trustradius-review-scraper`) Actor

Scrape verified software reviews, ratings & reviewer insights from TrustRadius. Extract review text, scores, verified badges, company profiles & sentiment data. Ideal for competitive intelligence, brand monitoring, market research & AI training datasets.

- **URL**: https://apify.com/shahidirfan/trustradius-review-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## TrustRadius Review Scraper

Extract verified B2B software reviews from TrustRadius product pages with pagination support. Collect detailed user reviews including ratings, pros and cons, reviewer information, and structured product data for market research and competitive analysis.

### Features

- **Product Data Extraction** - Pull structured product information including total review count and product slug
- **Full Review Collection** - Extract review text, use cases, pros, cons, recommendation notes, ratings, and publication dates
- **Rich Reviewer Firmographics** - Capture reviewer name, country, job title, department, company industry, company size, and years of experience for B2B analysis
- **Reliable Collection** - Uses fast HTTP requests with mobile-style headers and fallback profiles
- **Reviewer Insights** - Capture author names, dates, experience, and detailed feedback for each review

### Use Cases

#### Competitive Intelligence
Track how competing products are rated on TrustRadius. Compare review sentiment, common pros and cons, and overall satisfaction scores across similar software categories.

#### Market Research
Build comprehensive datasets of user feedback for specific software categories. Analyze trends in user satisfaction, feature requests, and common complaints to identify market opportunities.

#### Content Analysis
Study authentic user feedback to understand what users value most in different software categories. Extract common themes, use cases, and deployment scenarios from detailed B2B reviews.

#### Sales Intelligence
Equip sales teams with real user feedback data. Understand competitor weaknesses and strengths through authentic review content to refine positioning and messaging.

---

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrl` | String | Yes | - | Full TrustRadius product or reviews URL (e.g. `https://www.trustradius.com/products/slack/reviews/all`) |
| `results_wanted` | Integer | No | `20` | Maximum number of reviews to collect |
| `proxyConfiguration` | Object | No | Disabled | Optional proxy fallback for reliable scraping |

---

### Output Data

Each item in the dataset is an individual review record.

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | String | Always `"review"` |
| `productName` | String | Name of the software product |
| `productSlug` | String | Product identifier |
| `reviewCount` | Integer | Total number of reviews available for the product |
| `reviewSlug` | String | Unique review slug |
| `title` | String | Review title |
| `rating` | String | Review rating on a 1-10 scale |
| `ratingNormalized` | Integer | Normalized rating value (0-10) |
| `publishedDateText` | String | Human-readable publication date |
| `trusted` | Boolean | Trust badge value |
| `incentive` | String | Incentive disclosure |
| `reviewSource` | String | Review source classification |
| `author` | String | Reviewer full name |
| `authorFirst` | String | Reviewer first name |
| `authorLast` | String | Reviewer last name |
| `reviewerJobTitle` | String | Reviewer position title |
| `reviewerJobType` | String | Reviewer job type |
| `reviewerDepartment` | String | Reviewer department |
| `companyName` | String | Reviewer company name |
| `companyIndustry` | String | Reviewer company industry |
| `companySize` | String | Reviewer company size |
| `yearsExperience` | Integer | Years of experience using the product |
| `isVerified` | Boolean | Whether reviewer verification is present |
| `verifiedBy` | String | Verification source |
| `useCases` | String | Full use case and deployment scope text |
| `pros` | Array | Pros listed by the reviewer |
| `cons` | Array | Cons listed by the reviewer |
| `likelihoodToRecommend` | String | Full recommendation text |
| `publishedDate` | String | Review publication date (ISO) |
| `url` | String | Direct review URL |

---

### Usage Examples

#### Basic Review Extraction

Extract reviews from any TrustRadius product page:

```json
{
  "startUrl": "https://www.trustradius.com/products/slack/reviews/all",
  "results_wanted": 50
}
````

#### Using a Different Product

```json
{
  "startUrl": "https://www.trustradius.com/products/asana/reviews/all",
  "results_wanted": 100
}
```

#### With Proxy Configuration

```json
{
  "startUrl": "https://www.trustradius.com/products/miro/reviews",
  "results_wanted": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

***

### Sample Output

```json
{
  "recordType": "review",
  "productName": "Apify",
  "productSlug": "apify",
  "reviewCount": 122,
  "reviewSlug": "apify-2026-05-25-10-50-41",
  "title": "highly recommended for web scraping",
  "rating": "10/10",
  "ratingNormalized": 10,
  "publishedDate": "2026-05-29T17:01:22.186Z",
  "publishedDateText": "May 29, 2026",
  "trusted": false,
  "incentive": "No",
  "reviewSource": "VendorSourced",
  "author": "Matthias Werner",
  "authorFirst": "Matthias",
  "authorLast": "Werner",
  "reviewerJobTitle": "CRM Specialist",
  "reviewerJobType": "Engineer",
  "reviewerDepartment": "Other",
  "companySize": "1-10 employees",
  "yearsExperience": 1,
  "useCases": "Web scraping of social data for a data product. It makes it easy to scrape data without the need of cumbersome and extensive maintenance.",
  "pros": ["Scraping data from YouTube", "Scraping data from Facebook", "Scraping data from Tiktok"],
  "cons": ["Pricing could be a bit more intuitive or pure pay-as-you-go"],
  "likelihoodToRecommend": "I think Apify is very well suited for standardized data scraping or data extraction use cases.",
  "url": "https://www.trustradius.com/reviews/apify-2026-05-25-10-50-41",
  "source": "html-flight"
}
```

***

### Tips for Best Results

#### Choose Valid Product URLs

- Use direct product review URLs like `https://www.trustradius.com/products/{slug}/reviews/all`
- Verify the product page exists and has reviews before running at scale
- Product slugs are typically the URL-friendly version of the product name

#### Optimize Collection Size

- Start with small test runs of 10-20 reviews to verify extraction quality
- Increase `results_wanted` for production data collection
- Increase `results_wanted` to collect additional review pages

#### Proxy Configuration

- Use Apify Residential proxies for reliable access to TrustRadius
- Higher concurrency may require more proxy rotation
- Default proxy configuration uses datacenter proxies for cost efficiency

***

### Integrations

Connect your data with:

- **Google Sheets** - Export review data for collaborative analysis
- **Airtable** - Build searchable review databases
- **Slack** - Get notifications when new review data is collected
- **Make** - Create automated workflows with review data
- **Zapier** - Trigger actions based on collection results

#### Export Formats

- **JSON** - For developers and API integration
- **CSV** - For spreadsheet analysis and reporting
- **Excel** - For business reporting and presentations
- **XML** - For system integrations

***

### Frequently Asked Questions

#### How many reviews can I collect?

You can collect all available reviews for any product by increasing `results_wanted`.

#### Can I scrape multiple products?

Yes, provide each product URL in separate runs or configure multiple runs through Apify schedules. Each run processes one product URL at a time.

#### Why use TrustRadius review data?

TrustRadius hosts in-depth B2B software reviews (400+ words) with rich reviewer firmographics including company size, industry, job title, and years of experience.

#### What data fields are extracted?

The actor extracts product information and review details including title, use cases, pros, cons, recommendation text, rating, author, company details, and date.

#### Does this actor require a browser?

No. The actor uses HTTP requests and parses TrustRadius's structured page payload, so it stays fast and lightweight. A proxy is optional and only used when you provide one.

***

### Support

For issues or feature requests, contact support through the Apify Console.

#### Resources

- [Apify Documentation](https://docs.apify.com/)
- [API Reference](https://docs.apify.com/api/v2)
- [Scheduling Runs](https://docs.apify.com/schedules)

***

### Legal Notice

This actor is designed for legitimate data collection purposes. Users are responsible for ensuring compliance with TrustRadius terms of service and applicable laws. Use data responsibly and respect rate limits.

# Actor input Schema

## `startUrl` (type: `string`):

Full TrustRadius product or reviews URL (e.g. https://www.trustradius.com/products/slack/reviews/all)

## `results_wanted` (type: `integer`):

Maximum number of reviews to collect

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

Optional fallback proxy. The actor tries the stable direct API first and only uses proxy fallback when this is enabled.

## Actor input object example

```json
{
  "startUrl": "https://www.trustradius.com/products/apify/reviews/all",
  "results_wanted": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrl": "https://www.trustradius.com/products/apify/reviews/all",
    "results_wanted": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/trustradius-review-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 = {
    "startUrl": "https://www.trustradius.com/products/apify/reviews/all",
    "results_wanted": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/trustradius-review-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrl": "https://www.trustradius.com/products/apify/reviews/all",
  "results_wanted": 20
}' |
apify call shahidirfan/trustradius-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shahidirfan/trustradius-review-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustRadius Review Scraper ⭐",
        "description": "Scrape verified software reviews, ratings & reviewer insights from TrustRadius. Extract review text, scores, verified badges, company profiles & sentiment data. Ideal for competitive intelligence, brand monitoring, market research & AI training datasets.",
        "version": "0.0",
        "x-build-id": "xUqy0lPR5gzu4ctb4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahidirfan~trustradius-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahidirfan-trustradius-review-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/shahidirfan~trustradius-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-shahidirfan-trustradius-review-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/shahidirfan~trustradius-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-shahidirfan-trustradius-review-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrl": {
                        "title": "Product Review URL",
                        "type": "string",
                        "description": "Full TrustRadius product or reviews URL (e.g. https://www.trustradius.com/products/slack/reviews/all)"
                    },
                    "results_wanted": {
                        "title": "Maximum number of reviews",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional fallback proxy. The actor tries the stable direct API first and only uses proxy fallback when this is enabled.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
