# Trustradius Review Extractor (`kawsar/trustradius-review-extractor`) Actor

Extract TrustRadius reviews by keyword, including scores, reviewer roles, companies, industries, and review dates, so you can research products and build targeted lead lists without any manual copy-paste.

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

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Extractor

Extract B2B software reviews from TrustRadius by keyword. Enter one or more search terms like `crm`, `help desk`, or a specific product name, and this actor pages through the TrustRadius review search and returns every review as clean, structured data.

It is built for teams who need review data at scale: competitor and market research, product intelligence, lead lists filtered by industry and company size, and verified social proof for marketing and sales.

### Why use this actor

Collecting reviews from TrustRadius by hand is slow. You scroll, copy, paste, and still end up with messy notes. This actor does the whole job for you:

- Searches TrustRadius reviews for any keyword you give it.
- Pages through the results automatically until it hits your limit.
- Returns one clean record per review, ready for a spreadsheet, database, or BI tool.
- Runs several keywords in a single run.
- Exports to JSON, CSV, or Excel, or streams through the Apify API.

### How it works

You provide a list of keywords. For each keyword, the actor opens the matching TrustRadius review search and reads every review card on the page. If you ask for more reviews than one page holds, it moves to the next page and keeps going until it reaches your per-keyword limit or runs out of reviews.

Each review comes back with the product, the reviewer, their company and role, the score, the date, and a short excerpt.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQueries` | array of strings | yes | One keyword per line. Each keyword is a product name, category, or search term. Every keyword returns its own set of reviews. |
| `maxItems` | integer | no | Maximum reviews to collect per keyword. Default 25, max 1000. The actor pages through results until it reaches this number. |
| `requestTimeoutSecs` | integer | no | Per-request timeout in seconds. Default 30. |

#### Example input

```json
{
  "searchQueries": ["crm", "help desk", "project management"],
  "maxItems": 100
}
````

This run collects up to 100 reviews for each of the three keywords, so up to 300 reviews in total.

### Output

Each review is one record in the dataset. Example:

```json
{
  "searchQuery": "crm",
  "productName": "Sage Intacct",
  "productSlug": "sage-intacct",
  "reviewTitle": "Happy Sage Intacct Customer",
  "reviewUrl": "https://www.trustradius.com/reviews/sage-intacct-2026-06-26-09-29-04",
  "reviewerName": "Ryan Popper",
  "reviewerPosition": "CFO",
  "reviewerProfileUrl": "https://www.trustradius.com/users/6a3e8b70a3748818a1ad6a3d",
  "companyName": "Carnegie",
  "industry": "Higher Education",
  "companySize": "201-500 employees",
  "reviewDate": "July 01, 2026",
  "score": 10,
  "scoreText": "Score 10 out of 10",
  "verified": true,
  "reviewSnippet": "We use it for close, reporting, and multi-entity consolidation...",
  "scrapedAt": "2026-07-02T12:00:00+00:00"
}
```

#### Fields

| Field | Description |
|-------|-------------|
| `searchQuery` | The keyword this review was found under. |
| `productName` | Product being reviewed. |
| `productSlug` | URL-friendly product identifier. |
| `reviewTitle` | Headline the reviewer gave. |
| `reviewUrl` | Link to the full review. |
| `reviewerName` | Reviewer name, or "Verified User" when anonymous. |
| `reviewerPosition` | Reviewer job title. |
| `reviewerProfileUrl` | Link to the reviewer profile, when public. |
| `companyName` | Reviewer company, when listed. |
| `industry` | Company industry. |
| `companySize` | Employee count band. |
| `reviewDate` | Date the review was published. |
| `score` | Rating from 1 to 10. |
| `scoreText` | Raw score text as shown on the page. |
| `verified` | Whether the review is marked verified. |
| `reviewSnippet` | Short excerpt of the review body. |
| `scrapedAt` | UTC timestamp of the run. |

### Common use cases

- **Competitor research:** pull reviews for a rival product and see what users praise and complain about.
- **Market analysis:** compare scores and sentiment across a whole category like CRM or help desk.
- **Lead generation:** build lists of companies using a product, filtered by industry and size.
- **Sales enablement:** collect verified quotes and scores to use as social proof.
- **Product intelligence:** track how a product is rated over time by running the actor on a schedule.

### Export and integrations

Download results as JSON, CSV, or Excel straight from the run's dataset. For automated pipelines, read the dataset through the Apify API or connect the actor to your own tools with webhooks and scheduled runs.

### Tips and limits

- TrustRadius shows 25 reviews per results page. Set `maxItems` above 25 to page deeper into the results for a keyword.
- Scores and dates are returned exactly as TrustRadius displays them.
- Some reviewers post anonymously, so `reviewerName`, `reviewerProfileUrl`, and `companyName` can be empty on those records.
- Use several focused keywords rather than one broad term to get the most relevant reviews.

### Frequently asked questions

**Can I search more than one keyword at once?**
Yes. Add each keyword on its own line in `searchQueries`. Each one is searched separately and tagged in the output with `searchQuery`.

**How many reviews can I get per keyword?**
Up to 1000, set with `maxItems`. The actor pages through the results to reach your number.

**What format is the output?**
Structured records you can export as JSON, CSV, or Excel, or pull through the Apify API.

**Do I need to log in to TrustRadius?**
No. Just enter your keywords and run the actor.

# Actor input Schema

## `searchQueries` (type: `array`):

One keyword per line. Each keyword is a product name, category, or search term, such as "crm", "salesforce", or "project management". Every keyword returns its own set of matching reviews.

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

Maximum number of reviews to collect for each keyword. The actor pages through the results until it reaches this number or runs out of reviews.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchQueries": [
    "crm",
    "help desk"
  ],
  "maxItems": 25,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "searchQueries": [
        "crm",
        "help desk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/trustradius-review-extractor").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 = { "searchQueries": [
        "crm",
        "help desk",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/trustradius-review-extractor").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 '{
  "searchQueries": [
    "crm",
    "help desk"
  ]
}' |
apify call kawsar/trustradius-review-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustradius Review Extractor",
        "description": "Extract TrustRadius reviews by keyword, including scores, reviewer roles, companies, industries, and review dates, so you can research products and build targeted lead lists without any manual copy-paste.",
        "version": "0.0",
        "x-build-id": "wopOEIJR3TUgX7o1l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~trustradius-review-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-trustradius-review-extractor",
                "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/kawsar~trustradius-review-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-trustradius-review-extractor",
                "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/kawsar~trustradius-review-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-trustradius-review-extractor",
                "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",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One keyword per line. Each keyword is a product name, category, or search term, such as \"crm\", \"salesforce\", or \"project management\". Every keyword returns its own set of matching reviews.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max reviews per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each keyword. The actor pages through the results until it reaches this number or runs out of reviews.",
                        "default": 25
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```