# Capterra Software Scraper (`crawlerbros/capterra-scraper`) Actor

Scrape software product data from Capterra.com, extract product details, ratings, reviews, pricing, features, deployment options, and more from the world's largest software directory.

- **URL**: https://apify.com/crawlerbros/capterra-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Software Scraper

Extract **comprehensive software product data** from **Capterra.com** — the world's largest software directory. Get 39 fields per product including pricing plans, 100+ features, 3000+ integrations, pros/cons, vendor info, and more.

### How It Works

Capterra is protected by aggressive Cloudflare Turnstile and blocks direct scraping. But **Capterra, GetApp, and SoftwareAdvice are all owned by Gartner Digital Markets (GDM)** and share a **single product catalog**. This scraper takes advantage of that:

1. **Google SERP** — resolves the Capterra product URL to the equivalent GetApp URL
2. **GetApp direct fetch** — GetApp exposes the full GDM catalog via `__NEXT_DATA__` (~500KB of structured JSON per product)
3. **Rich extraction** — parses 39 fields: name, tagline, pricing plans, features, integrations, platforms, support, training, pros/cons, vendor, and more

Result: you get the same rich Capterra data **without touching Capterra** — free, reliable, and faster than fighting anti-bot systems.

### Features

- **39 output fields** per product — the most complete Capterra data available
- **Pricing plans** with starting prices and feature lists
- **101+ features** list + total count
- **3000+ integrations** list + total count
- **Pros/cons** with sentiment topics and summaries
- **Vendor info** — name, location, website, founded year
- **Platforms, support options, training options, typical customers**
- **Screenshots** URLs
- **100% reliable** — no Cloudflare challenges to solve
- **No nulls** — every field has a typed default

### Input

| Field | Type | Description |
|---|---|---|
| `productUrls` | Array | Capterra product URLs (e.g., `https://www.capterra.com/p/135003/Slack/`) |
| `maxItems` | Integer | Max products to scrape (default 20) |

#### Example Input

```json
{
    "productUrls": [
        "https://www.capterra.com/p/135003/Slack/",
        "https://www.capterra.com/p/228385/Notion/"
    ],
    "maxItems": 10
}
````

### Output

Each product has **39 fields**:

#### Identity

| Field | Type | Description |
|---|---|---|
| `productId` | String | Capterra numeric product ID |
| `slug` | String | Product slug |
| `name` | String | Product name |
| `url` | String | Capterra product URL |
| `reviewsUrl` | String | Capterra reviews page URL |
| `tagline` | String | Product tagline |
| `description` | String | Short description |
| `overview` | String | Longer product overview |
| `logo` | String | Product logo URL |

#### Ratings

| Field | Type | Description |
|---|---|---|
| `rating` | Number | Overall rating (0–5) |
| `reviewCount` | Integer | Total number of reviews |

#### Pricing

| Field | Type | Description |
|---|---|---|
| `startingPrice` | String | Starting price with currency & period (e.g., `$8.75 / month`) |
| `pricingModel` | String | Pricing model (e.g., `Per User`, `Flat Rate`) |
| `priceCurrency` | String | Currency code |
| `pricePeriodicity` | String | Billing period |
| `freeTrial` | Boolean | Free trial available |
| `freeVersion` | Boolean | Free version available |
| `pricingPlans` | Array | Pricing plans with name, price, attributes |
| `licensingModel` | String | Licensing model (e.g., `Proprietary`) |

#### Categories & Features

| Field | Type | Description |
|---|---|---|
| `categories` | Array | Software categories |
| `primaryCategory` | String | Primary category |
| `features` | Array | Up to 50 feature names |
| `featureCount` | Integer | Total feature count |
| `integrationsCount` | Integer | Total integrations count |
| `integrations` | Array | Up to 20 integration names |
| `platforms` | Array | Supported platforms |
| `supportOptions` | Array | Customer support options |
| `trainingOptions` | Array | Training options |
| `typicalCustomers` | Array | Target customer sizes |

#### Pros / Cons / Visuals

| Field | Type | Description |
|---|---|---|
| `pros` | Array | Positive sentiment topics with summary |
| `cons` | Array | Negative sentiment topics with summary |
| `screenshots` | Array | Screenshot image URLs |

#### Vendor

| Field | Type | Description |
|---|---|---|
| `vendorName` | String | Vendor company name |
| `vendorCity` | String | Vendor city |
| `vendorState` | String | Vendor state |
| `vendorCountry` | String | Vendor country |
| `vendorWebsite` | String | Vendor website URL |
| `vendorFoundedYear` | Integer | Vendor founding year |

| `scrapedAt` | String | ISO 8601 scrape timestamp |

#### Example Output

```json
{
    "productId": "135003",
    "slug": "Slack",
    "name": "Slack",
    "url": "https://www.capterra.com/p/135003/Slack/",
    "reviewsUrl": "https://www.capterra.com/p/135003/reviews",
    "tagline": "A single place for team communication and workflows",
    "description": "Slack is a single workspace that connects users with the people and tools they work with...",
    "logo": "https://gdm-catalog-fmapi-prod.imgix.net/ProductLogo/...",
    "rating": 4.66,
    "reviewCount": 24046,
    "startingPrice": "$8.75 / month",
    "pricingModel": "Per User",
    "freeTrial": true,
    "freeVersion": true,
    "pricingPlans": [
        {"name": "Free", "attributes": ["1 workspace", "10 Integrations"]},
        {"name": "Pro", "attributes": ["Unlimited message history", "..."]}
    ],
    "licensingModel": "Proprietary",
    "primaryCategory": "Team Communication",
    "categories": ["Unified Communications", "Content Collaboration", "..."],
    "featureCount": 101,
    "integrationsCount": 3180,
    "platforms": ["Web-based", "iPad", "Mac"],
    "typicalCustomers": ["Small Business", "Mid-size Business", "Large Enterprises"],
    "vendorName": "Slack",
    "vendorCountry": "United States",
    "vendorFoundedYear": 2014,
    "scrapedAt": "2026-04-10T12:00:00+00:00"
}
```

### FAQ

**Q: Why doesn't the scraper fetch Capterra directly?**
Capterra is protected by Cloudflare Turnstile, which blocks all datacenter and most residential IPs. We instead fetch the same product data from GetApp (a sister site in the GDM catalog), which exposes everything via its `__NEXT_DATA__` JSON.

**Q: How accurate is the GetApp data compared to Capterra?**
100% accurate — Capterra, GetApp, and SoftwareAdvice all query the same Gartner Digital Markets (GDM) catalog. The underlying product, rating, review count, and feature data are identical across all three sites.

**Q: Does this scraper collect individual user reviews?**
No — this scraper extracts product metadata + aggregated pros/cons sentiment topics. For individual review text, you'd need a separate scraper.

**Q: How do I find Capterra product URLs?**
Go to [capterra.com](https://www.capterra.com), search for a software product, and copy the URL from the product page. URLs follow the pattern `https://www.capterra.com/p/{id}/{name}/`.

### Use Cases

- **Competitive research** — compare products across pricing, features, integrations
- **Market analysis** — track category trends, pricing models
- **Feature-based product discovery** — filter by platforms, integrations, support
- **Vendor intelligence** — identify software companies by location and size
- **Due diligence** — gather structured data for software selection

# Actor input Schema

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

List of Capterra product URLs to scrape. Example: https://www.capterra.com/p/135003/Slack/

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

Maximum number of products to scrape.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.capterra.com/p/135003/Slack/"
  ],
  "maxItems": 1
}
```

# Actor output Schema

## `products` (type: `string`):

No description

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Capterra Software Scraper",
        "description": "Scrape software product data from Capterra.com, extract product details, ratings, reviews, pricing, features, deployment options, and more from the world's largest software directory.",
        "version": "1.0",
        "x-build-id": "zcc21VCRsSaVZrQ7P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~capterra-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~capterra-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~capterra-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "List of Capterra product URLs to scrape. Example: https://www.capterra.com/p/135003/Slack/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of products to scrape.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```