# Capterra & Software Advice Reviews Scraper (`piquno/capterra-software-advice-reviews-scraper`) Actor

Scrape software reviews from Capterra and Software Advice in one run, deduplicated across both sites. HTTP-only, no browser. 40 flat fields per review.

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

## Pricing

from $1.50 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Capterra + Software Advice Reviews Scraper

Scrape software reviews from **Capterra** and **Software Advice** in a single run, deduplicated across both. HTTP-only — no browser. 41 flat fields per review, ready for CSV or Excel.

**$1.50 per 1,000 reviews.** No charge for empty rows.

***

### Why this one

Capterra and Software Advice are both Gartner-family properties (acquired by G2 in February 2026) and they **republish the same review corpus under the same review ids**. A Slack review carries the id `Capterra___7079722` on both sites, and both report the same 24,181 total.

Measured on live data: **48% of the Software Advice reviews for Slack were already present on Capterra.** If you scrape the two sites with separate actors today, you pay twice for roughly half your rows and then have to reconcile them yourself.

This actor emits each review **once**, with `sourcePlatform` recording where it came from.

#### What else is different

| | This actor | Typical incumbent |
|---|---|---|
| Cross-site dedupe | Yes, on shared review id | None — separate actors per site |
| Repeat runs | `incremental` emits only new reviews | Re-bills full history every run |
| Empty rows | Never billed | Commonly billed |
| Filters | Applied **before** billing | Often applied after |
| Missing data | Stays `null` | Sometimes inferred |

The `incremental` and no-bill-on-empty behaviours deliberately reduce what you are charged on scheduled runs. That is the point: a monitoring job should cost a few cents a week, not re-purchase 24,000 reviews every Monday.

***

### Input

```json
{
  "targets": ["https://www.capterra.com/p/135003/Slack/"],
  "platforms": ["capterra", "softwareadvice"],
  "maxReviewsPerTarget": 500,
  "dedupeAcrossPlatforms": true,
  "minRating": 1,
  "maxRating": 3,
  "proxyConfiguration": { "proxyUrls": ["http://user:pass@your-residential-provider:port"] }
}
```

**`targets`** accepts:

- a Capterra product URL — `https://www.capterra.com/p/135003/Slack/`
- the short form — `capterra:135003/Slack`
- a Software Advice profile URL — `https://www.softwareadvice.com/remote-support/slack-profile/`

Software Advice must be a full URL. Its path contains a category segment (`remote-support`) that cannot be derived from a Capterra id, and guessing one would silently return the wrong product.

#### Monitoring a product

Set `incremental: true` and give each schedule its own `stateKey`. The actor remembers review ids between runs and emits only ones it has not seen, tagged `changeType: "new"`.

***

### Output

One flat row per review. Nested objects are flattened; nothing is nested, so CSV and Excel exports stay usable.

```json
{
  "reviewId": "Capterra___7189737",
  "productName": "Slack",
  "sourcePlatform": "capterra",
  "title": "Slack: Essential for Desk Based Workforces",
  "prosText": "Slack is the best way for a desk based workforce to communicate…",
  "consText": "Honestly, nothing. Occasionally there will be a bug…",
  "overallRating": 5,
  "easeOfUseRating": 5,
  "customerSupportRating": 5,
  "functionalityRating": 5,
  "valueForMoneyRating": 5,
  "recommendationRating": 10,
  "writtenOn": "2026-07-25T00:00:00.000Z",
  "incentivized": "NoIncentive",
  "reviewerName": "Richard M.",
  "reviewerJobTitle": "Founder",
  "reviewerIndustry": "Marketing and Advertising",
  "reviewerCompanySize": "Self-employed",
  "reviewerTimeUsed": "2+ years",
  "reviewerIsValidated": true,
  "reviewerVerifiedLinkedIn": true,
  "fieldsPopulated": 28
}
```

#### Field fill rates

Measured over a full page of live Capterra reviews. Published so you can judge completeness before you buy, not after.

| Field | Fill |
|---|---|
| `reviewId`, `title`, `writtenOn` | 100% |
| `prosText`, `consText` | 100% |
| all five sub-ratings, `recommendationRating` | 100% |
| `generalComments` | 96% |
| `reasonsForSwitching` | 20% |
| `adviceToOthers` | 0% on this sample |

`frequencyOfUsing`, `reasonsForChoosing` and `hasPreviousVersions` (review edit history) come from Software Advice and are `null` on Capterra rows.

Software Advice returns a **coded** company size (`"G"`) with no legend published on the page. The code is passed through as `reviewerCompanySizeCode` and `reviewerCompanySize` is left `null` — this actor does not guess a mapping it cannot verify.

***

### Pricing

| Event | Price |
|---|---|
| Review | **$0.0015** ($1.50 / 1,000) |
| Actor start | $0.00005 |

A row is billed only if it has a review id and at least one of pros, cons, or comments, and it is billed **before** it is pushed — so you are never charged for a row you did not receive, and never receive one you were not charged for.

Rows removed by your filters are never billed. The actor also honours the **maximum charge per run** you set in the run options: once that budget is exhausted it stops fetching rather than continuing to spend compute on pages it can no longer bill.

***

### Limitations — read before you buy

- **A third-party residential proxy is required. Apify Proxy does not work on this target.** Measured 2026-08-21:

  | Route | Success rate |
  |---|---|
  | Consumer ISP address, direct | 1 / 3 |
  | Apify Proxy — datacenter and `RESIDENTIAL`, via impit and got-scraping | 0 / 11 |

  Capterra's Cloudflare blocks Apify's proxy ranges specifically, so this is not fixed by retries, by rotating sessions, or by changing HTTP client. Supply your own residential proxy under **Custom proxies** in the proxy input (`proxyUrls`). Budget roughly 680 KB per page of 25 reviews when estimating proxy spend.

  Cloudflare also degrades a single address with volume: a clean IP starts near 100% and decays toward zero, so a rotating pool matters more than a fast one.
- **G2.com is not supported.** G2 runs DataDome in blocking mode and returns 403 on every content URL including its own advertised sitemap. It gates on TLS and JS-derived signals, so proxies do not help. Actors claiming G2 coverage are the ones with the lowest ratings on the Store, and blocking is why.
- **GetApp is not supported.** Its product pages reference Capterra review ids but do not carry the review bodies. Since the corpus is shared with Capterra, adding it would mostly duplicate rows you already have.
- **25 reviews per page.** A product with 24,000 reviews needs ~960 requests for a full history. Use `maxReviewsPerTarget`, date filters, or `incremental` rather than pulling everything.
- **Format risk.** Reviews are read from the Next.js React Server Component payload. If the site changes its internals, extraction falls back to JSON-LD, which is thinner (author, title, rating) but correct — the actor degrades rather than returning nothing.

***

### Running locally

```bash
npm install
npm test
```

Tests run against captured live pages in `test/fixtures/` — no network required.

# Actor input Schema

## `targets` (type: `array`):

Capterra product URLs (https://www.capterra.com/p/135003/Slack/), the short form capterra:135003/Slack, or Software Advice profile URLs (https://www.softwareadvice.com/remote-support/slack-profile/). Software Advice must be given as a full URL — its category segment cannot be derived from a Capterra id.

## `platforms` (type: `array`):

Which sites to pull from. Capterra and Software Advice publish the same review corpus with the same review ids, so enabling both without dedupe will return duplicates.

## `maxReviewsPerTarget` (type: `integer`):

Hard limit per product per platform. 25 reviews are returned per page.

## `dedupeAcrossPlatforms` (type: `boolean`):

Emit each review once even when it appears on both Capterra and Software Advice. In testing, 48% of Software Advice reviews were already present on Capterra.

## `incremental` (type: `boolean`):

Remember review ids between runs and emit only ones not seen before. Turns a scheduled monitor into a cheap delta instead of re-billing the full history every run.

## `stateKey` (type: `string`):

Namespace for incremental state. Use a different key per saved search so separate schedules do not share history.

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

Only reviews rated at or above this value (1-5).

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

Only reviews rated at or below this value (1-5). Combine with minimum to isolate detractors.

## `fromDate` (type: `string`):

ISO date, e.g. 2026-01-01.

## `toDate` (type: `string`):

ISO date, e.g. 2026-08-01.

## `verifiedOnly` (type: `boolean`):

Keep only reviews whose reviewer passed source validation.

## `excludeIncentivized` (type: `boolean`):

Drop reviews where the reviewer received an incentive.

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

Use CUSTOM PROXIES with your own residential provider. Apify Proxy does not work on this target — Capterra's Cloudflare blocks Apify's datacenter and residential ranges (measured 0/11, versus 1/3 from a consumer ISP address). Budget ~680 KB per page of 25 reviews.

## Actor input object example

```json
{
  "targets": [
    "https://www.capterra.com/p/135003/Slack/"
  ],
  "platforms": [
    "capterra"
  ],
  "maxReviewsPerTarget": 500,
  "dedupeAcrossPlatforms": true,
  "incremental": false,
  "stateKey": "default",
  "verifiedOnly": false,
  "excludeIncentivized": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per review: product, ratings, pros and cons, reviewer profile, verification and incentive flags. Deduplicated across Capterra and Software Advice when dedupeAcrossPlatforms is enabled.

## `runSummary` (type: `string`):

Counts for the run: rows pushed, reviews billed, cross-platform duplicates skipped, unchanged reviews skipped in incremental mode, and rows removed by filters.

# 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 = {
    "targets": [
        "https://www.capterra.com/p/135003/Slack/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("piquno/capterra-software-advice-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 = { "targets": ["https://www.capterra.com/p/135003/Slack/"] }

# Run the Actor and wait for it to finish
run = client.actor("piquno/capterra-software-advice-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 '{
  "targets": [
    "https://www.capterra.com/p/135003/Slack/"
  ]
}' |
apify call piquno/capterra-software-advice-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,piquno/capterra-software-advice-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/lXtEu4fADPzHDghZu/builds/v9NNIIGgC0916ofqh/openapi.json