# Capterra & SaaS Reviews Scraper — Pros, Cons, Ratings (`lergassy/software-reviews-scraper`) Actor

Scrape SaaS and software reviews from Capterra, Software Advice, TrustRadius and GetApp in one schema: pros and cons, ratings, reviewer job title, company size, industry and vendor replies. No login.

- **URL**: https://apify.com/lergassy/software-reviews-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.84 / 1,000 review scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Scrape B2B software reviews from **Capterra**, **Software Advice**, **GetApp** and **TrustRadius** and get every source back in the same fields. Pros and cons as separate columns, five sub-ratings, reviewer job title, industry and company size, vendor replies, incentive flags and the exact publication date. No login, no cookies, no API key.

### What is Software Reviews Scraper?

Software Reviews Scraper is a **software review API** for four review sites: Capterra, Software Advice, GetApp and TrustRadius. Give it a product name or a product page, and it returns one row per review plus one summary row per product.

Most review scrapers cover a single site and invent their own field names, so comparing a product across two sites means writing a translation layer first. This Actor normalises everything: a review from Capterra and a review from Software Advice arrive with identical keys, so `overallRating` means the same thing wherever the row came from.

| What you give it | What you get back |
| --- | --- |
| A product name, such as `Slack` | The matching product on each site you pick, with its reviews |
| A Capterra product URL | Every review, newest first, with pros, cons and sub-ratings |
| A Software Advice product URL | The same fields, same names |
| Several products at once | One dataset you can group by product and by site |
| A rating or date filter | Only the reviews you asked for |

#### Which review sites are supported?

| Site | Reviews available | Rating scale | Notes |
| --- | --- | --- | --- |
| Capterra | Full history, 25 per page | 1-5 | Richest source: sub-ratings, alternatives considered, switching reasons |
| Software Advice | Full history, 25 per page | 1-5 | Adds usage frequency and length of use |
| TrustRadius | Full history, 10 per page | 1-10 | Longest review text, plus reviewer company, department and years of experience |
| GetApp | The review showcase the page publishes (about 6) | 1-5 | Product ratings and totals are complete |

Capterra, Software Advice and GetApp run on one review database, so a review carries the same `reviewId` wherever it appears — useful for de-duplicating across those three. TrustRadius is a separate site with its own reviewers.

#### Ratings on two different scales

TrustRadius rates out of 10 while the other three rate out of 5. Both numbers are returned: `overallRating` keeps the site's own scale, `ratingScale` says which scale that is, and `normalizedRating` converts everything to 1-5 so a sort or an average across sites means something. Rating filters work on the normalized value, so `maxRating: 3` returns the same band of unhappy customers on every site.

### What data can Software Reviews Scraper extract?

| Field | Type | Example |
| --- | --- | --- |
| `source` | string | `capterra` |
| `sourceLabel` | string | `Capterra` |
| `productName` | string | `Slack` |
| `productUrl` | string | `https://www.capterra.com/p/135003/Slack/reviews/` |
| `productRating` | number | `4.4642` |
| `productReviewCount` | integer | `11145` |
| `reviewId` | string | `Capterra___7189737` |
| `title` | string | `Slack: Essential for Desk Based Workforces` |
| `publishedAt` | string | `2026-07-25` |
| `overallRating` | number | `5` |
| `easeOfUseRating` | number | `5` |
| `functionalityRating` | number | `5` |
| `valueForMoneyRating` | number | `4` |
| `customerSupportRating` | number | `5` |
| `recommendationScore` | number | `10` |
| `pros` | string | `Slack is the best way for a desk based workforce to communicate…` |
| `cons` | string | `Occasionally there will be a bug…` |
| `comments` | string | `I love Slack and could not run my business without it…` |
| `adviceToOthers` | string | `Start with fewer channels than you think you need.` |
| `reviewerName` | string | `Richard M.` |
| `reviewerJobTitle` | string | `Founder` |
| `reviewerIndustry` | string | `Marketing and Advertising` |
| `reviewerCompanySize` | string | `Self-employed` |
| `reviewerCompanySizeCode` | string | `C` |
| `reviewerCompany` | string | `SDLC Corp` |
| `reviewerDepartment` | string | `Information Technology` |
| `reviewerYearsExperience` | integer | `4` |
| `ratingScale` | integer | `10` |
| `normalizedRating` | number | `4.5` |
| `reviewUrl` | string | `https://www.trustradius.com/reviews/slack-2026-08-05-00-29-43` |
| `reviewerVerified` | boolean | `true` |
| `timeUsed` | string | `Less than 2 years` |
| `usageFrequency` | string | `Daily` |
| `incentivized` | boolean | `false` |
| `incentiveType` | string | `NominalGift` |
| `vendorResponse` | string | `Thanks for the detailed feedback…` |
| `reasonsForChoosing` | string | `Price and integrations` |
| `alternativeProducts` | array | `["Microsoft Teams", "Discord"]` |
| `switchedFrom` | array | `["Skype"]` |
| `ratingBreakdown` | object | `{"5": 17379, "4": 5725, "3": 911}` (product rows) |
| `status` / `errorCode` / `errorMessage` | string | `ok`, or why a URL failed |
| `scrapedAt` | string | `2026-09-05T04:20:11+00:00` |

#### A note on company size

Capterra publishes a readable range such as `11-50 employees`, which lands in `reviewerCompanySize`. Software Advice and GetApp publish a single letter (`A` to `I`) instead, and neither site publishes what those letters mean. Rather than guess, the Actor passes the letter through in `reviewerCompanySizeCode` and leaves `reviewerCompanySize` empty. Nothing is invented.

### How much does it cost to scrape software reviews?

Pay-per-event pricing, so the bill follows the rows you keep.

| Event | Price | When it is charged |
| --- | --- | --- |
| Review scraped | $0.0012 | Per review written to the dataset |
| Product scraped | $0.003 | Per product summary row |

**Failed URLs are never charged.** A dead link, a page that does not exist, or a site that refuses the request comes back as an `error` row at no cost.

| Job | Cost |
| --- | --- |
| 1,000 reviews for one product | $1.20 |
| 10,000 reviews across 10 products | $12.03 |
| 200 recent reviews for 25 competitors | $6.08 |
| Product ratings only, 100 products | $0.30 |

Comparable single-site review Actors charge between $0.90 and $5.49 per 1,000 reviews. This one sits near the bottom of that range while covering three sites in one schema. There are no proxy costs: pages are fetched over plain HTTPS.

The Apify Free plan includes $5 of monthly usage, which is about **4,000 reviews** before you pay anything.

### How to scrape Capterra reviews

1. Click **Try for free** and sign in to Apify.
2. Paste one or more product URLs into **Product review URLs**. A plain product link works; the reviews path is added for you.
3. Set **Max reviews per product**. Reviews come newest first, so 200 gives you the most recent 200.
4. Optionally set a rating or date filter — `maxRating: 3` collects complaints only.
5. Press **Start**, then open the **Output** tab or export as JSON, CSV or Excel.

### ⬇️ Input

![Software Reviews Scraper input: Capterra and Software Advice product URLs, review limit, rating and date filters](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/software-reviews-scraper/software-reviews-scraper-input-form.png)

```json
{
  "searchTerms": ["Slack", "Asana"],
  "searchSites": ["capterra", "trustradius"],
  "maxReviews": 200,
  "includeProductRow": true
}
```

#### Searching by product name

Put product names in **🔍 Product names** and skip the URL hunt. Each name is looked up on
every site in **Sites to search**, and the best match is scraped — so `Slack` returns the
Slack reviews from Capterra *and* from TrustRadius in one dataset, ready to compare.

Matching prefers products whose name carries the words you typed, then the one with the
most reviews, which keeps integrations and add-ons from stealing the slot: `Zoom` resolves
to Zoom Workplace and its 14,000 reviews, not to a small app called ZooM. Every row that
came from a search carries the `searchTerm` it was found by.

Raise **Products per name** above 1 to pull the closest alternatives alongside the product
itself — a quick way to build a category comparison from a single keyword.

GetApp has no search page of its own and its URLs need a category that no other site
publishes, so GetApp is reachable by URL only. A name that matches nothing on a site comes
back as an `error` row naming the site and the term; the other sites still run.

#### Choosing products

Any product page on the four sites works. These are all valid:

- `https://www.capterra.com/p/135003/Slack/`
- `https://www.capterra.com/p/135003/Slack/reviews/`
- `https://www.softwareadvice.com/project-management/slack-profile/reviews/`
- `https://www.getapp.com/collaboration-software/a/slack/reviews/`
- `https://www.trustradius.com/products/slack/reviews`

#### Sorting what comes back

**Sort reviews by** orders the rows: newest, oldest, highest or lowest rating, or the order
the site itself published them. It sorts what the run collected — the sites offer no sort
of their own — so to control *which* reviews are collected, use the rating and date filters
below. Asking for `maxRating: 2` finds every one- and two-star review by paging until it
has them, which is what a "lowest rating first" sort is usually a proxy for.

#### Collecting only the reviews you need

`minRating` and `maxRating` filter on the overall star rating. `publishedAfter` and `publishedBefore` take `YYYY-MM-DD` dates. Filters are applied while paging, so a run set to 300 complaints keeps reading until it has found 300 or the site runs out of reviews.

#### Proxies

Not required. The Actor reaches all three sites directly, which is why the price carries no proxy surcharge. The proxy field exists only as a fallback if a site starts refusing your particular runs.

### ⬆️ Output

![Software Reviews Scraper output table: Capterra and Software Advice reviews side by side with the same columns](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/software-reviews-scraper/software-reviews-scraper-output-table.png)

One row per review:

```json
{
  "rowType": "review",
  "source": "capterra",
  "sourceLabel": "Capterra",
  "productName": "Slack",
  "reviewId": "Capterra___7189737",
  "title": "Slack: Essential for Desk Based Workforces",
  "publishedAt": "2026-07-25",
  "overallRating": 5,
  "easeOfUseRating": 5,
  "functionalityRating": 5,
  "valueForMoneyRating": 5,
  "customerSupportRating": 5,
  "recommendationScore": 10,
  "pros": "Slack is the best way for a desk based workforce to communicate.",
  "cons": "Occasionally there will be a bug or issue, but that is once in a blue moon.",
  "reviewerName": "Richard M.",
  "reviewerJobTitle": "Founder",
  "reviewerIndustry": "Marketing and Advertising",
  "reviewerCompanySize": "Self-employed",
  "reviewerVerified": true,
  "incentivized": false,
  "status": "ok",
  "scrapedAt": "2026-09-05T04:20:11+00:00"
}
```

And one summary row per product:

```json
{
  "rowType": "product",
  "sourceLabel": "Software Advice",
  "productName": "Slack",
  "productRating": 4.6639,
  "productReviewCount": 24190,
  "ratingBreakdown": { "5": 17379, "4": 5725, "3": 911, "2": 127, "1": 48 },
  "ratings": { "overall": 4.6639, "easeOfUse": 4.6114, "customerSupport": 4.4286 }
}
```

#### Why one schema matters

Run the same product on two sites and the rows line up column for column. Capterra rates Slack 4.46 across 11,145 reviews; Software Advice rates the same product 4.66 across 24,190. That gap is visible in one sort, without reconciling two field naming schemes first.

#### Error rows

| `errorCode` | Meaning |
| --- | --- |
| `unsupported-site` | The URL is not one of the three supported sites |
| `not-found` | The product page does not exist |
| `blocked` | The site refused the request; retry, or add a proxy |
| `http-error` | The site answered with an unexpected status |
| `network-error` | The site could not be reached |

### Use cases for software review data

#### Competitor and win-loss research

Pull every review of your competitors, filter to `maxRating: 3`, and read what their customers complain about. `reasonsForSwitching` and `switchedFrom` name the products buyers left behind.

#### Product feedback and roadmap input

Collect your own reviews with `publishedAfter` set to the last quarter and group `cons` by `reviewerIndustry` or job title to see which segment is unhappy.

#### Feeding an LLM or a RAG pipeline

Every review arrives as clean text with a date and a rating, which is what a summarisation or sentiment prompt needs. Because `pros` and `cons` are separate fields, you can prompt each side independently instead of asking a model to split the text again.

#### Lead generation and sales research

`reviewerJobTitle`, `reviewerIndustry` and the products a reviewer switched away from describe a buying decision already made in public.

#### Market and category monitoring

Schedule a run weekly across a category, keep the product rows, and track how average ratings and review volumes move over time.

### Integrations

- **API**: `POST https://api.apify.com/v2/acts/lergassy~software-reviews-scraper/runs`
- **Python**: `ApifyClient(token).actor('lergassy/software-reviews-scraper').call(run_input={'productUrls': [...]})`
- **JavaScript**: `await client.actor('lergassy/software-reviews-scraper').call({ productUrls: [...] })`
- **n8n**: use the Apify node and set a **max total charge** so a scheduled run cannot exceed your budget.
- **Make, Zapier, Google Sheets, Airtable**: map the dataset straight into a sheet or table.
- **MCP**: available through the Apify MCP server, so Claude, Cursor and other MCP clients can call it as a tool.
- **Webhooks**: fire a webhook when a run finishes and pass the dataset onward.

### 🤖 For AI agents and LLM apps

```json
{ "productUrls": ["https://www.capterra.com/p/135003/Slack/reviews/"], "maxReviews": 50 }
```

- One row per review; `rowType` separates `review`, `product` and `error` rows.
- Field names never change between sites, so a prompt written once works for all three.
- `pros` and `cons` are separate strings — no text splitting needed.
- `incentivized` flags reviews written in exchange for a gift, which matters when weighing sentiment.
- Failed URLs are returned as rows and are never charged, so agent retries stay cheap.

### ❓ FAQ

#### Is it legal to scrape software reviews?

The Actor reads pages that are public and require no login, and it collects the review text and the reviewer details each site already publishes. How you may store and use that data depends on your jurisdiction and on the sites' terms, so review both before running at scale. This is not legal advice.

#### Do I need a proxy or an API key?

No. The three sites are reached directly, with no key, cookie or proxy.

#### How many reviews can I get for one product?

As many as the site publishes. Capterra and Software Advice page through their whole history 25 reviews at a time; popular products have tens of thousands. GetApp publishes only a short showcase, and the Actor says so in the run log rather than pretending otherwise.

#### Can I search by product name instead of hunting for URLs?

Yes. Put the names in **Product names** and pick the sites in **Sites to search**. Capterra,
Software Advice and TrustRadius can all be searched; GetApp needs a product URL because it
publishes no search page. Searching costs nothing extra — you pay for the reviews and
product rows you get back.

#### Does it scrape G2?

No. G2 sits behind a bot-protection service that this Actor deliberately does not try to defeat. Capterra, Software Advice, GetApp and TrustRadius cover the same buyers and are reachable cleanly.

#### How are TrustRadius scores out of 10 handled?

Both ways. `overallRating` keeps the 9-out-of-10 the site published, `ratingScale` records that it was a 10-point scale, and `normalizedRating` gives you 4.5 so the row lines up with a Capterra review.

#### Can I get only negative reviews?

Yes: set **Maximum star rating** to 2 or 3. The Actor keeps paging until it has collected the number you asked for.

#### Can I use it with the Apify API?

Yes, like any Apify Actor: start a run, then read the dataset.

#### Can I use it through an MCP server?

Yes, it is exposed through the Apify MCP server as a callable tool.

#### Why is company size sometimes a single letter?

Because that is what Software Advice and GetApp publish. See the note above — the letter is passed through untouched rather than guessed at.

#### How fresh is the data?

Reviews are read live at run time, newest first, so a run reflects the site at that moment.

### Your feedback

Missing a field, or a site you need covered? Open an issue on the **Issues** tab or leave a review — issues are answered quickly, and requests shape what gets built next.

### You might also like

| Actor | What it does |
| --- | --- |
| [Document Text Extractor](https://apify.com/lergassy/document-text-extractor) | PDF, Word, Excel and PowerPoint to Markdown, tables and RAG chunks |
| [Email & Phone Verifier](https://apify.com/lergassy/email-phone-verifier) | Validate e-mail addresses and phone numbers, find contacts on a website |
| [US Business Leads](https://apify.com/lergassy/us-business-filings) | New business registrations from US state and city registries |
| [Agoda Reviews Scraper](https://apify.com/lergassy/agoda-reviews-scraper) | Hotel reviews and ratings from Agoda and Booking.com |

# Actor input Schema

## `searchTerms` (type: `array`):

Names of the products you want reviews for, one per line — for example <code>Slack</code>. Each name is looked up on the sites chosen below and the best match is scraped. Leave empty if you already have product URLs.

## `searchSites` (type: `array`):

Where to look the names up. GetApp has no search page of its own, so it can only be reached with a product URL.

## `maxProductsPerTerm` (type: `integer`):

How many matching products to scrape for each name on each site. Keep it at 1 for the exact product; raise it to compare a name against its closest alternatives.

## `productUrls` (type: `array`):

Product pages on Capterra, Software Advice, GetApp or TrustRadius. Paste the product URL — the Actor adds the reviews path itself. Mix sites freely: every source comes back with the same field names.

## `maxReviews` (type: `integer`):

How many reviews to collect for each product. Reviews arrive 25 per page, newest first.

## `minRating` (type: `integer`):

Keep only reviews at or above this rating, on a 1-5 scale. TrustRadius scores out of 10 are converted before filtering.

## `maxRating` (type: `integer`):

Keep only reviews at or below this rating, on a 1-5 scale. Set it to 3 to collect complaints only.

## `publishedAfter` (type: `string`):

Keep only reviews published on or after this date, in <code>YYYY-MM-DD</code> format.

## `publishedBefore` (type: `string`):

Keep only reviews published on or before this date, in <code>YYYY-MM-DD</code> format.

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

Order the reviews come back in. The sites publish no sort of their own, so this orders what the run collected; to decide <i>which</i> reviews are collected use the rating and date filters above.

## `includeProductRow` (type: `boolean`):

Add one row per product with the average rating, the total review count and the star breakdown.

## `maxConcurrency` (type: `integer`):

How many products to scrape at the same time.

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

How long to wait for one page before giving up on it.

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

Optional. The Actor works without a proxy; add one only if the sites start refusing your runs.

## Actor input object example

```json
{
  "searchTerms": [
    "Slack"
  ],
  "searchSites": [
    "trustradius"
  ],
  "maxProductsPerTerm": 1,
  "productUrls": [
    "https://www.capterra.com/p/135003/Slack/reviews/"
  ],
  "maxReviews": 100,
  "sortReviews": "as_published",
  "includeProductRow": true,
  "maxConcurrency": 3,
  "requestTimeoutSecs": 45,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

Dataset with reviews and product summaries.

## `reviewsInConsole` (type: `string`):

Browse the scraped reviews in the Apify Console.

# 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 = {
    "searchTerms": [
        "Slack"
    ],
    "searchSites": [
        "trustradius"
    ],
    "productUrls": [
        "https://www.capterra.com/p/135003/Slack/reviews/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/software-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": ["Slack"],
    "searchSites": ["trustradius"],
    "productUrls": ["https://www.capterra.com/p/135003/Slack/reviews/"],
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/software-reviews-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "Slack"
  ],
  "searchSites": [
    "trustradius"
  ],
  "productUrls": [
    "https://www.capterra.com/p/135003/Slack/reviews/"
  ]
}' |
apify call lergassy/software-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/software-reviews-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/iwSGXxEw42NLikuIk/builds/08aVQaZGJ6lBCSZIP/openapi.json