# Capterra Scraper (`kawsar/capterra-scraper`) Actor

Pulls reviews, ratings, pricing, and feature scores from Capterra product pages so you can keep tabs on software reputation or compare vendors without doing it by hand.

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

## Pricing

from $10.00 / 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

## Capterra Scraper

![Capterra Scraper](https://i.imgur.com/Lkr969d.png)

Extract reviews, ratings, pricing, features, integrations, and alternatives from any Capterra software product page. Give it a URL, get back structured JSON.

### What it does

Capterra Scraper visits a product page and pulls the overall star rating, per-feature scores, reviewer profiles, pros and cons, pricing tiers, integration lists, and alternatives. One JSON object per URL.

### Why bother

Software reviews are one of the few places you get honest feedback about a product that nobody asked for. Capterra has millions of them, and the data sits there in HTML, one page at a time.

Some things you can do once it's in a database: schedule the actor daily on your own Capterra page and you'll know within hours when a new review lands. Run it on a competitor's page to track if they're picking up complaints about a specific feature. Pull a shortlist of vendor tools and compare them without opening a browser — the output is normalized, same fields every time. Or pipe the review text into a sentiment or LLM pipeline. Reviewer role, industry, rating breakdown, pros, cons, full body text are all there.

Reviews go stale if you check them once and move on. The actor is most useful running on a schedule.

If you need every review a software has ever received, not just the first page, the [Capterra Reviews Scraper](https://apify.com/kawsar/capterra-reviews-scraper) does that with no limit.

### Input

```json
{
  "startUrls": [
    "https://www.capterra.com/p/150854/Apify/",
    "https://www.capterra.com/p/172606/Smallpdf/"
  ],
  "maxReviews": 10,
  "maxItems": 10,
  "requestTimeoutSecs": 30
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array of strings | required | Capterra product page URLs |
| `maxReviews` | integer | 10 | Max reviews to extract per product (up to 500) |
| `maxItems` | integer | 10 | Max product pages to process per run (up to 1000) |
| `requestTimeoutSecs` | integer | 30 | Per-request timeout in seconds |

### Output

One JSON object per URL.

| Field | Description |
|---|---|
| `productName` | Software name |
| `logoUrl` | Direct URL to the product logo image |
| `productDescription` | Full description text |
| `category` | Application category |
| `overallRating` | Overall star rating (float, out of 5) |
| `reviewCount` | Total published reviews |
| `lastUpdated` | Date the Capterra listing was last updated |
| `ratings` | Breakdown: overall, easeOfUse, features, customerService, valueForMoney, likelihoodToRecommend |
| `startingPrice` | Cheapest paid plan price and billing cycle |
| `hasFreeVersion` | Boolean |
| `hasFreeTrial` | Boolean |
| `pricingPlans` | Array of plan objects — name, price, billing info, included features |
| `featureRatings` | Per-feature ratings with review counts and summaries |
| `integrations` | List of integration names |
| `supportOptions` | Available support channels |
| `userIndustries` | Industries using the product with percentages |
| `userCompanySizes` | Company size breakdown with percentages |
| `alternatives` | Competing products with ratings, pricing, free trial/version info |
| `keyTakeaways` | Capterra "what is it used for" summary |
| `ourVerdict` | Capterra editorial verdict (when present) |
| `reviews` | Individual reviews: reviewer name, role, industry, rating breakdown, body, pros, cons, date |
| `scrapedAt` | ISO 8601 UTC timestamp |
| `error` | Error message if scraping failed, otherwise null |

### Sample output on Apify platform

Table view:

![Table view sample](https://i.imgur.com/7AGWPr7.png)

JSON view:

![JSON view sample](https://i.imgur.com/heaim7p.png)

### Example output (abbreviated)

```json
{
  "url": "https://www.capterra.com/p/150854/Apify/",
  "productName": "Apify",
  "overallRating": 4.8,
  "reviewCount": 427,
  "lastUpdated": "April 16, 2026",
  "ratings": {
    "overall": 4.8,
    "easeOfUse": 4.7,
    "featureRating": 4.8,
    "customerService": 4.7,
    "valueForMoney": 4.6,
    "likelihoodToRecommend": 9.2
  },
  "hasFreeVersion": true,
  "hasFreeTrial": true,
  "pricingPlans": [
    {
      "planName": "Free",
      "price": "$0.00",
      "billingInfo": "",
      "planFeatures": ["4 GB Actor RAM", "7 Days of Data Retention", "Community Support"]
    },
    {
      "planName": "Starter Plan",
      "price": "$29.00",
      "billingInfo": "Usage Based, Per Month",
      "planFeatures": ["14 Days of Data Retention", "30 Shared Data Center Proxies", "Email Support"]
    }
  ],
  "integrations": ["Google Docs", "Google Drive", "Slack", "Dropbox Business", "Asana", "GitHub", "Zapier", "Make"],
  "alternatives": [
    {
      "alternativeName": "Octoparse",
      "alternativeRating": 4.7,
      "alternativeReviewCount": 106,
      "startingPrice": "$99 Flat Rate, Per Month",
      "hasFreeVersion": true,
      "hasFreeTrial": true
    }
  ],
  "reviews": [
    {
      "reviewerName": "Dennis L.",
      "reviewerRole": "Founder",
      "reviewerIndustry": "Media Production",
      "reviewTitle": "Great for vibecoders",
      "reviewOverallRating": 5.0,
      "reviewDate": "April 16, 2026",
      "reviewBody": "I discovered Apify a couple of months ago because I needed a way to scrape different sites...",
      "reviewPros": "super easy to incorporate with Claude. easy to test in Apify's console too...",
      "reviewCons": "search console should be easier to take you to show all actors..."
    }
  ],
  "scrapedAt": "2026-04-19T10:30:00+00:00",
  "error": null
}
```

### Scheduling

In the actor's schedule settings, pick a daily or weekly cron. Each run pushes new data to the dataset. Connect that to webhooks, Zapier, or Make to route results wherever you need them.

### Want countless reviews?

This actor pulls the reviews visible on the first page of a product listing. If you need every single review a software has ever received, use the dedicated [Capterra Reviews Scraper](https://apify.com/kawsar/capterra-reviews-scraper), which pages through all reviews with no cap.

### Notes

- By default, up to 10 reviews per page are extracted, which matches what Capterra loads on first visit. Use `maxReviews` to adjust.
- URLs should be Capterra product pages in the format `https://www.capterra.com/p/<id>/<ProductName>/`
- Failed URLs produce an item with an `error` field rather than stopping the whole run.

# Actor input Schema

## `startUrls` (type: `array`):

One or more Capterra product page URLs to scrape. Example: https://www.capterra.com/p/150854/Apify/

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

Maximum number of reviews to extract per product page.

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

Maximum number of product pages to process per run.

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

Per-request timeout in seconds.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.capterra.com/p/150854/Apify/"
  ],
  "maxReviews": 10,
  "maxItems": 10,
  "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 = {
    "startUrls": [
        "https://www.capterra.com/p/150854/Apify/",
        "https://www.capterra.com/p/172606/Smallpdf/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/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 = { "startUrls": [
        "https://www.capterra.com/p/150854/Apify/",
        "https://www.capterra.com/p/172606/Smallpdf/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/capterra-scraper").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 '{
  "startUrls": [
    "https://www.capterra.com/p/150854/Apify/",
    "https://www.capterra.com/p/172606/Smallpdf/"
  ]
}' |
apify call kawsar/capterra-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Capterra Scraper",
        "description": "Pulls reviews, ratings, pricing, and feature scores from Capterra product pages so you can keep tabs on software reputation or compare vendors without doing it by hand.",
        "version": "0.0",
        "x-build-id": "5pfHSEoQJ3gPBE3VK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~capterra-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-capterra-scraper",
                "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~capterra-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-capterra-scraper",
                "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~capterra-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-capterra-scraper",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more Capterra product page URLs to scrape. Example: https://www.capterra.com/p/150854/Apify/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per product page.",
                        "default": 10
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of product pages to process per run.",
                        "default": 10
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
