# TrustRadius Software Extractor (`kawsar/trustradius-software-extractor`) Actor

TrustRadius Software Extractor scrapes software products, star ratings, review counts, and categories from any TrustRadius search, so you can build directories, compare tools, and enrich B2B lead lists without copy and paste.

- **URL**: https://apify.com/kawsar/trustradius-software-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 Software Extractor

TrustRadius Software Extractor scrapes software products from TrustRadius search results. Type in a category or keyword such as project management, CRM, or help desk, and the actor walks through the search pages and pulls back every matching product. For each one you get the product name, its star rating, how many reviews it has, the category it belongs to, the logo image, a link to the product page, and the short summary snippet that TrustRadius shows in search.

Pagination is handled for you. Give it a search term and a limit, and a single run can return hundreds of products with no clicking and no copy-paste.

### Why use this actor

TrustRadius holds thousands of B2B software listings with community ratings and reviews. Pulling that data by hand is slow and error prone. This actor turns a search term into a clean, structured dataset you can sort, filter, and load into your own tools in seconds.

Common uses:

- Build a directory of every product in a software category
- Compare star ratings and review counts across competing tools
- Track how a product's rating and review count move over time by running on a schedule
- Enrich a CRM or product database with TrustRadius ratings
- Build a B2B prospect list of vendors in a specific niche
- Feed market research, competitor monitoring, or investment screening

### How it works

You give the actor one or more search terms. For each term it opens the TrustRadius products search, reads the results, then follows the pagination until it either reaches your per-term limit or runs out of products. Every product is saved as its own record in the dataset, tagged with the search term it came from and its position in the results.

Duplicate products inside a single search are filtered out, so each product shows up once per term.

### Input

You control the run with a short list of settings. Only the search terms are required.

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQueries` | array of strings | Yes | Search terms to look up, one per line. For example `project management`, `crm`. |
| `maxItems` | integer | No | Maximum number of products to collect for each search term. Default 100, max 1000. |
| `requestTimeoutSecs` | integer | No | Per-request timeout in seconds. Default 45. |

Note that `maxItems` applies per search term, not to the whole run. With two terms and a limit of 100, a run can return up to 200 products.

#### Example input

```json
{
    "searchQueries": ["project management", "crm"],
    "maxItems": 200,
    "requestTimeoutSecs": 45
}
````

This collects up to 200 project management products and up to 200 CRM products, for a possible 400 records in total.

### Output

Each product becomes one record in the dataset. Example record:

```json
{
    "searchTerm": "crm",
    "productId": "6158f9e6a3a18500401fea35",
    "productName": "MACAW CRM",
    "productUrl": "https://www.trustradius.com/products/macaw-crm/reviews",
    "logoUrl": "https://media.trustradius.com/product-logos/qf/NH/X19LTO9PGEEA-180x180.JPEG",
    "rating": 4.0,
    "ratingText": "1 Rating",
    "reviewCount": 1,
    "category": "Other Insurance Suites Software",
    "snippet": "MACAW CRM system has been designed exclusively for the insurance sector...",
    "resultPosition": 1,
    "totalResults": 3351,
    "scrapedAt": "2026-07-02T10:00:00+00:00",
    "error": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `searchTerm` | string | The search term this product was found under. |
| `productId` | string | TrustRadius internal product id. |
| `productName` | string | Product name. |
| `productUrl` | string | Link to the product's reviews page on TrustRadius. |
| `logoUrl` | string | Product logo image URL. |
| `rating` | number | Star rating from 0 to 5, or null when there are not enough ratings. |
| `ratingText` | string | The rating label TrustRadius shows, for example "12 Ratings". |
| `reviewCount` | integer | Number of reviews, when available. |
| `category` | string | The software category the product belongs to. |
| `snippet` | string | Short summary text from the search result. |
| `resultPosition` | integer | Rank of the product within the search results for its term. |
| `totalResults` | integer | Total number of products TrustRadius reports for the term. |
| `scrapedAt` | string | UTC timestamp of when the record was collected. |
| `error` | string | Populated only when a page could not be fetched, otherwise null. |

### Exporting your data

Results land in a standard Apify dataset. You can download them as JSON, CSV, Excel, or XML from the run's Storage tab, or pull them straight through the Apify API into your own pipeline. This makes it easy to drop the data into a spreadsheet, a database, or a BI tool.

### Running on a schedule

Set the actor to run on a schedule if you want to watch ratings and review counts change over time. Each run writes a fresh dataset with a `scrapedAt` timestamp on every record, so you can line up snapshots and see which products are gaining reviews or losing ground.

### Tips

- Start with a small `maxItems` value to preview the shape of the data before a large run.
- Broad terms like `crm` return thousands of products. Use `maxItems` to keep run time and cost in check.
- Use several narrow terms instead of one broad one when you want tighter, more relevant results.
- Some products have no rating yet. In that case `rating` is null and `ratingText` explains there are not enough reviews.

### Frequently asked questions

**Which search terms can I use?**
Anything you would type into the TrustRadius product search: a category like `business intelligence`, a use case like `team chat`, or a product keyword.

**How many products can I get per term?**
Up to 1000 per search term, set with `maxItems`. The actor stops early if TrustRadius runs out of matching products first.

**Do I need to log in?**
No. You only supply search terms and limits.

**What happens if a page fails to load?**
That term gets a single record with an `error` message and the actor moves on, so one hiccup never sinks the whole run.

**Are ratings live?**
Yes. Ratings and review counts reflect what TrustRadius displays at the moment of the run.

# Actor input Schema

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

Software categories or keywords to search on TrustRadius, one per line. For example: project management, crm, help desk.

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

Maximum number of products to collect for each search term. With two terms and a limit of 100, a run can return up to 200 products.

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

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchQueries": [
    "project management",
    "crm"
  ],
  "maxItems": 25,
  "requestTimeoutSecs": 45
}
```

# 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": [
        "project management"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/trustradius-software-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": ["project management"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/trustradius-software-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": [
    "project management"
  ]
}' |
apify call kawsar/trustradius-software-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustRadius Software Extractor",
        "description": "TrustRadius Software Extractor scrapes software products, star ratings, review counts, and categories from any TrustRadius search, so you can build directories, compare tools, and enrich B2B lead lists without copy and paste.",
        "version": "0.0",
        "x-build-id": "DkqWzBwzq8u9EatWU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~trustradius-software-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-trustradius-software-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-software-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-trustradius-software-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-software-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-trustradius-software-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",
                "properties": {
                    "searchQueries": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Software categories or keywords to search on TrustRadius, one per line. For example: project management, crm, help desk.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per search term",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of products to collect for each search term. With two terms and a limit of 100, a run can return up to 200 products.",
                        "default": 25
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
