# Capterra  Reviews Scraper 2026 (`devcake/capterra-scraper`) Actor

Scrape Capterra review data instantly — detailed ratings, verified reviewer identities, job titles, company sizes, and real
pros/cons for your research.

- **URL**: https://apify.com/devcake/capterra-scraper.md
- **Developed by:** [devcake](https://apify.com/devcake) (community)
- **Categories:** Other, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 52 total users, 10 monthly users, 66.1% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Capterra Review Scraper ⭐

**Extract verified software reviews from Capterra** — ratings, reviewer metadata, pros/cons, detailed comments. Fast direct API scraping at scale.

***

### ⭐ What It Does

This tool pulls **verified software reviews** directly from Capterra without needing a browser. It grabs the full review picture — overall score, sub-ratings (ease of use, value for money, functionality, customer support), pros/cons, author details, and more — then outputs structured JSON ready for analysis, import, or integration.

***

### 👥 Who It's For

- **Product teams** — gather user feedback to prioritize roadmaps and fix pain points
- **Marketers & brand managers** — monitor sentiment across software categories
- **Analysts & researchers** — build training datasets, benchmark software vs. competitors
- **Lead gen & sales teams** — identify verified current-user reviews for social proof campaigns
- **Software reviewers & bloggers** — collect structured review data at scale

***

### ⭐ Data You Get

| Field | Description |
|-------|-------------|
| `review_id` | Unique Capterra review identifier |
| `product_id`, `product_slug`, `product_url` | Product the review belongs to, including in multi-product runs |
| `title` | Review headline |
| `body` | Full review text |
| `rating` | Overall star rating (1–5) |
| `author_name` | Reviewer display name |
| `author_job_title` | Their job role |
| `author_company_size` | Employee count bucket |
| `industry_name` | Industry sector |
| `date_published` | When the review was posted |
| `is_validated` | Verified Capterra user flag |
| `verified_linkedin` | LinkedIn profile verification status |
| `time_used_product` | How long the reviewer used the product |
| `customer_support_rating` | Sub-rating for support (1–5) |
| `ease_of_use_rating` | Sub-rating for ease of use (1–5) |
| `functionality_rating` | Sub-rating for features/functionality (1–5) |
| `value_for_money_rating` | Sub-rating for value for money (1–5) |
| `recommendation_rating` | Recommendation score (out of 10) |
| `pros_text` | Pros — what the reviewer liked |
| `cons_text` | Cons — what the reviewer disliked |
| `incentivized` | Incentive type (e.g. NominalGift) |
| `source` | Always `capterra` |
| `page` | Page number this review came from |

***

### 💡 Use Cases

#### Product Research & Competitive Analysis

Compare Capterra ratings across competitor software. Spot common complaints to find gaps your product can fill, or lean into strengths you already have.

#### Sentiment Analysis at Scale

Feed clean, structured review text into NLP pipelines. Filter by industry, rating, or time period for targeted sentiment studies.

#### Lead Generation from Verified Reviews

Pull reviewer metadata (job title, company size, industry) to build warm B2B outbound lists from real, verified users.

#### B2B SaaS Benchmarking

Track sub-ratings (ease of use, value for money, customer support) over time to benchmark how your product stacks up against the market.

#### Review Aggregation for Comparison Pages

Populate product comparison pages or internal wikis with real, up-to-date Capterra reviews — without manual copy-pasting.

***

### 🚀 Quick Start

**1.** Go to [Capterra Review Scraper](https://apify.com/devcake/Capterra-scraper) and click **Try it out**

**2.** Enter a product slug (e.g. `jira`, `slack`), an ID/slug pair (`135003/Slack`), or a full Capterra URL (`https://www.capterra.com/p/135003/Slack/reviews/`). Full URLs avoid an extra product lookup. Equivalent URLs and ID/slug pairs are combined into one product. A matching bare slug is also combined when the input identifies a single product ID for it.

Numeric product IDs alone (such as `204717`) need the URL slug too. Search matches canonical product names and verified aliases, and rejects ambiguous matches. If a name is not found, use the complete, current Capterra URL.

**3.** Set **Max Reviews** (min 30) and choose a **Sort Order**, then click **Start**

**4.** Download results as **JSON** from the dataset output

That's it. No setup needed.

***

### ⚙️ Input Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `queries` | array of strings | ✅ Yes | Product slugs, ID/slug pairs, or full product/review URLs. Example: `["jira", "135003/Slack"]`. |
| `max_reviews` | integer | No | Maximum number of reviews to scrape per product (min30, max 1000). Default: `50`. Each page returns ~20–25 reviews. |
| `sort` | string | No | Review sort order. Options: `HIGHEST_COMPLETENESS_SCORE` (default, most detailed reviews first) or `MOST_RECENT` (latest first). |
| `proxyConfiguration` | object | No | Defaults to Apify residential proxies. Supports country selection and custom proxy URLs. For local runs, set `PROXY_URL` when this input is omitted. |

***

### 📝 Example

#### Input

```json
{
  "queries": ["jira"],
  "max_reviews": 50,
  "sort": "MOST_RECENT"
}
```

#### Output

```json
[
  {
    "source": "capterra",
    "review_id": "Capterra___7133000",
    "title": "Powerful tool for managing development tasks and team collaboration",
    "body": "Overall, my experience with Jira has been very positive...",
    "rating": 5.0,
    "author_name": "Kaynan S.",
    "author_job_title": "Senior Software Engineer",
    "author_company_size": "51-200 employees",
    "industry_name": "Entertainment",
    "date_published": "April 17, 2026",
    "is_validated": true,
    "verified_linkedin": true,
    "time_used_product": "2+ years",
    "customer_support_rating": 4.0,
    "ease_of_use_rating": 4.0,
    "functionality_rating": 5.0,
    "value_for_money_rating": 5.0,
    "recommendation_rating": 9.0,
    "pros_text": "What I like most about Jira is how powerful it is for managing tasks...",
    "cons_text": "One downside is that Jira can feel a bit complex, especially for new users...",
    "incentivized": "NominalGift",
    "page": 1
  }
]
```

***

### ❓ FAQ

**Q: Do I need a proxy?**
A: The Actor uses Apify residential proxies by default. Capterra often blocks datacenter and direct connections.

**Q: How is this different from a traditional web scraper?**
A: Most scrapers need a full browser to load pages — slower startup, more memory, and extra overhead. This tool calls Capterra's data endpoint directly, so it starts instantly and handles large scrape jobs without breaking a sweat.

**Q: What does `recommendation_rating` mean?**
A: A 0–10 score measuring how strongly the reviewer recommends the product. It's separate from the 5-star overall rating and gives finer-grained signal for recommendation intent.

**Q: Can I scrape multiple products in one run?**
A: Yes. Enter multiple product slugs in the `queries` array (e.g. `["jira", "slack", "zendesk"]`). The scraper handles up to 3 concurrently per run.

**Q: What does `incentivized` mean?**
A: Indicates the incentive status reported by Capterra (e.g. `NominalGift` or `NoIncentive`). An empty string means the site did not specify it.

***

### ⚡ Features

- **Direct API access** — fast, lightweight, reliable at scale
- **Paginated scraping** — pull up to 1,000 unique reviews per product
- **Two sort options** — highest completeness, most recent
- **Verified reviewer data** — LinkedIn verification status, job title, company size, industry, time-using-product
- **Sub-category ratings** — customer support, ease of use, functionality, value for money, recommendation score

### Run quality and local testing

The `SUMMARY` output reports `complete`, `partial`, or `failed`, with the actual pages fetched and any per-product errors. Partial runs retain the reviews already collected; failed pages are reported rather than silently skipped. A product with fewer reviews than requested finishes normally when the source is exhausted.

Most Recent uses Capterra's cursor-based reviews action. Shared action discovery retries blocked connections, and sorted workers can retry discovery using their own session. Discovery can use independent reference products and a bounded set of live script/module references when component names or asset paths change. Requests use a minimal router state instead of depending on Capterra's private layout names. If the action remains unavailable, the run reports an error rather than returning the default order. Short default-sort runs use the review page data directly. Raw Flight responses and Flight embedded in HTML are supported, including long text and deferred references.

Blocked requests use a bounded budget of six proxy session rotations per product. Incomplete action responses retry the same cursor to avoid skipping reviews. Canonical URL redirects are handled separately from GET failures, and redirects to another product are rejected. Empty results or pagination that contradict the site's reported count produce an error. Most Recent also checks date order across page boundaries before exporting each page.

If the first default-sort review page is blocked twice, or repeatedly returns a healthy response without usable reviews, the scraper tries the reviews action with the same sort and continues with cursor pagination. Route responses must include pagination metadata. When more reviews are needed than the route provides, the scraper restarts through the cursor action before exporting anything; a shortened hybrid feed cannot be mistaken for a complete review page. Both transports share the existing rotation budget. Cloudflare challenge pages are recognized even with HTTP 200. Complete single-page results still skip action discovery. A failure after reviews have already been collected preserves partial results instead of switching pagination methods mid-run.

Run regression checks with `python -m unittest discover -s tests -v`. For live local checks, provide `PROXY_URL` through your environment and run `python local_traffic_test.py --queries jira --reviews 50 --sort MOST_RECENT`. Both `python main.py` and `python -m src.capterra` use the same Actor entry point.

For platform verification, `python scripts/platform_smoke.py start --build <candidate-tag>` starts bounded test runs on `devcake/Capterra-scraper`. Then run `python scripts/platform_smoke.py verify` to check completion, exact review counts, unique IDs, product attribution, decoded text, and Most Recent date order. These commands use `APIFY_TOKEN` or the authenticated Apify CLI and consume normal Actor/proxy usage. Deploy candidates with an explicit tag and promote only after verification; the local Actor configuration targets the public Actor.

Additional cases are available through `python scripts/extended_smoke.py start --build <candidate-tag> --manifest output/extended.json`, followed by `python scripts/extended_smoke.py verify --manifest output/extended.json`. These cover small-product overview redirects and exhaustion, matching GET/POST fields and order, the 99/100-review transport boundary, equivalent references, six products, tracking parameters, and custom proxies. Small-product expected counts are date-specific and should be checked against the live source when reviews are added or removed.

# Actor input Schema

## `queries` (type: `array`):

Enter Capterra URL slugs (jira), ID/slug pairs (135003/Slack), or full Capterra product/review URLs. Canonical product names and verified aliases are matched when available in search. Numeric IDs alone and free-text sentences are rejected. Full URLs avoid search ambiguity.

## `max_reviews` (type: `integer`):

Maximum number of reviews to scrape per product. Each page returns ~20–25 reviews. Minimum 30.

## `sort` (type: `string`):

Choose how reviews are sorted. <b>Highest Completeness</b> returns most detailed reviews first. <b>Most Recent</b> returns latest reviews first.

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

Apify residential proxies are used by default. You can select a country or provide custom proxies.

## Actor input object example

```json
{
  "queries": [
    "jira"
  ],
  "max_reviews": 50,
  "sort": "HIGHEST_COMPLETENESS_SCORE",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Complete dataset of scraped reviews in raw JSON format. Each item is a single review object.

## `summary` (type: `string`):

Statistics and metadata about this scrape run: total reviews scraped, pages scraped, errors encountered, and per-product stats.

# 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 = {
    "queries": [
        "jira"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("devcake/capterra-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 = { "queries": ["jira"] }

# Run the Actor and wait for it to finish
run = client.actor("devcake/capterra-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 '{
  "queries": [
    "jira"
  ]
}' |
apify call devcake/capterra-scraper --silent --output-dataset

```

## MCP server setup

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