# PeerSpot Enterprise Software Reviews Scraper (`automation-lab/peerspot-enterprise-software-reviews-scraper`) Actor

Extract public PeerSpot enterprise software reviews, ratings, reviewer context, pros, cons, and competitor insights.

- **URL**: https://apify.com/automation-lab/peerspot-enterprise-software-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## PeerSpot Enterprise Software Reviews Scraper

Export public enterprise-software reviews from PeerSpot into an analysis-ready Apify dataset.

### What does it do?

This actor collects public review records from PeerSpot product review pages.

Each row combines review text with product ratings, reviewer context, pros, and cons.

Use it for evidence-based positioning, competitive research, and sales enablement.

### Who is it for?

🧑‍💼 Product marketers can monitor customer language around a category or competitor.

📊 Competitive-intelligence teams can compare recurring strengths and objections.

🤝 Sales-enablement teams can find public use cases and implementation concerns.

🛠️ Data teams can export structured review data to their warehouse or BI tool.

### Why use it?

PeerSpot pages expose public structured review information that is awkward to copy manually.

The actor converts that information into consistent JSON records.

It is HTTP-first, does not require a PeerSpot account, and keeps collection limits explicit.

### Public data only

The actor processes public PeerSpot pages only.

It does not log in, submit content, or attempt to access private account data.

Use it only for pages and data you are authorized to collect and process.

### Quick start

1. Open a public product review page on `peerspot.com`.

2. Paste its URL into **PeerSpot URLs**.

3. Start with 10–20 reviews for a small validation run.

4. Export the default dataset as JSON, CSV, or through the Apify API.

### Supported URLs

Product review URLs ending in `-reviews` are processed directly.

For example: `https://www.peerspot.com/products/slack-business-enterprise-reviews`.

Public listing pages are also accepted; the actor follows linked product-review URLs.

Listing expansion is capped by **Maximum products from listing pages**.

### Input fields

| Field | Description |
| --- | --- |
| `startUrls` | Public PeerSpot product-review or listing URLs. |
| `maxReviews` | Maximum review rows saved across the run. |
| `maxProducts` | Maximum review pages discovered from listing inputs. |

### Output fields

| Field | Description |
| --- | --- |
| `productName` | PeerSpot product name. |
| `productRating` | Public aggregate product rating, when present. |
| `productReviewCount` | Public aggregate review count, when present. |
| `reviewTitle` | Public review headline. |
| `reviewText` | Public review body. |
| `reviewRating` | Reviewer's rating, when present. |
| `reviewDate` | Published or created date, when present. |
| `reviewerName` | Public reviewer name or handle. |
| `reviewerJobTitle` | Public reviewer role. |
| `reviewerCompany` | Public affiliation/company. |
| `reviewerIndustry` | Public reviewer context supplied by PeerSpot. |
| `pros` / `cons` | Arrays of public positive and negative notes. |

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

The actor uses pay-per-event pricing: a small start event plus a result event for each saved review.

Volume tiers reduce the per-review price for larger usage plans.

The exact current event prices are displayed on the actor's Apify page before you run it.

Keep `maxReviews` low when validating a new workflow.

### Review-analysis workflow

🧭 Start with one product page to validate the fields you need.

🧭 Use several product pages to compare a vendor set.

🧭 Group `pros` and `cons` to identify themes across public reviews.

🧭 Keep `sourceUrl` with every downstream record for traceability.

### Competitive-intelligence workflow

Use listing pages to discover review pages, then set a conservative product limit.

Normalize `productName`, `reviewRating`, and review text in your data pipeline.

Compare repeated objections in `cons` with product messaging or battlecards.

Review public statements in context; do not treat one review as a universal claim.

### Sales-enablement workflow

Filter `reviewText` for deployment, integration, support, security, or migration language.

Use reviewer job title and affiliation as context, not as a contact database.

Build enablement themes from aggregate patterns rather than individual identities.

### Tips for reliable runs

✅ Prefer direct product-review URLs when you know the products you need.

✅ Use a small `maxReviews` first, then increase it after reviewing the dataset.

✅ Use multiple product URLs for a broader comparison set.

✅ Expect optional fields when a reviewer's public profile is limited.

### Limitations

A PeerSpot page can expose fewer review objects than its public aggregate review count.

The actor only saves reviews present in the public page's structured data at run time.

Listing page layouts can change and may expose no product-review links.

Account-only content is out of scope.

### Empty results

If a run yields no records, first confirm the URL is public and ends in `-reviews`.

For listing inputs, try a direct product review page instead.

Check the run log for a non-success HTTP status or a missing public Product data block.

### Invalid URL errors

Only public `www.peerspot.com` URLs are accepted.

Remove tracking parameters or copied text around the URL if validation fails.

The actor intentionally rejects other domains instead of acting as a general web scraper.

### Integrations

Send the dataset to Google Sheets or a warehouse for recurring review analysis.

Use Make or Zapier to trigger an internal brief when a monitored product is refreshed.

Feed review text into a clustering or sentiment workflow after applying your own governance.

Use `sourceUrl` as the durable citation in reports and dashboards.

### API usage: JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/peerspot-enterprise-software-reviews-scraper').call({
  startUrls: [{ url: 'https://www.peerspot.com/products/slack-business-enterprise-reviews' }],
  maxReviews: 20,
});
console.log(await client.dataset(run.defaultDatasetId).listItems());
````

### API usage: Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/peerspot-enterprise-software-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.peerspot.com/products/slack-business-enterprise-reviews"}],
    "maxReviews": 20,
})
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

### API usage: cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~peerspot-enterprise-software-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -X POST -H 'content-type: application/json' \
  -d '{"startUrls":[{"url":"https://www.peerspot.com/products/slack-business-enterprise-reviews"}],"maxReviews":20}'
```

### MCP with Claude Code

Add this actor to Apify MCP tools:

```bash
claude mcp add --transport http apify https://mcp.apify.com?tools=automation-lab/peerspot-enterprise-software-reviews-scraper
```

Example prompt: “Extract public PeerSpot reviews for these software products and summarize repeated pros and cons.”

#### MCP with Claude Desktop

Configure the Apify MCP server with your Apify token, then enable the actor tool above.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/peerspot-enterprise-software-reviews-scraper"
    }
  }
}
```

Ask Claude to run a small review export before requesting a broader comparison.

#### MCP with Cursor or VS Code

In Cursor, open **Settings → Tools & MCP → Add new global MCP server**. In VS Code with an MCP-capable extension, open its MCP server configuration JSON. Add this HTTP server entry, then reload the AI tools panel:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/peerspot-enterprise-software-reviews-scraper"
    }
  }
}
```

Example Cursor/VS Code prompt: “Use the PeerSpot Enterprise Software Reviews Scraper to collect 20 public reviews for Slack Business Enterprise and list recurring pros, cons, reviewer roles, and source URLs.”

Keep source URLs in the requested output for verifiable conclusions.

### Data handling

Review content may include public names, roles, or affiliations.

Handle exported data under your privacy, retention, and lawful-use obligations.

Do not use this actor to make decisions about people based solely on review metadata.

### Legality and ethical use

Respect PeerSpot's terms, applicable law, and the rights of data subjects.

Do not use the actor for harassment, identity resolution, or prohibited surveillance.

Rate-limit your own workflows thoughtfully and use only public URLs.

### FAQ

**Does this require a PeerSpot login?** No; it processes public pages only.

**Can I collect every review ever written?** No; results are limited to review objects publicly exposed on pages processed during the run.

**Why is a reviewer field blank?** PeerSpot may not expose that public attribute for every review.

**Can I use category pages?** Yes, where they link to public product-review pages.

### Troubleshooting FAQ

**The actor says no product URLs were found.** Use a direct URL ending in `-reviews`.

**The actor returned fewer records than expected.** Increase the number of product URLs or use listing expansion; a single page may expose a limited review sample.

### Related scrapers

For adjacent B2B review sources, explore [Automation Lab actors](https://apify.com/automation-lab).

Choose the source that best matches the buyer segment you need to analyze.

### Support

Include the input URL and run log excerpt when reporting a reproducible issue.

Never include account credentials or private data in support requests.

### Changelog

See [the actor changelog](.actor/CHANGELOG.md) for user-visible release notes.

# Actor input Schema

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

Add public PeerSpot product review URLs (ending in -reviews) or listing pages. Listing pages are expanded to product review pages.

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

Maximum public review records to save across all products.

## `maxProducts` (type: `integer`):

When a listing URL is used, stop after this many linked product-review pages.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.peerspot.com/products/slack-business-enterprise-reviews"
    }
  ],
  "maxReviews": 20,
  "maxProducts": 5
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.peerspot.com/products/slack-business-enterprise-reviews"
        }
    ],
    "maxReviews": 20,
    "maxProducts": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/peerspot-enterprise-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 = {
    "startUrls": [{ "url": "https://www.peerspot.com/products/slack-business-enterprise-reviews" }],
    "maxReviews": 20,
    "maxProducts": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/peerspot-enterprise-software-reviews-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": [
    {
      "url": "https://www.peerspot.com/products/slack-business-enterprise-reviews"
    }
  ],
  "maxReviews": 20,
  "maxProducts": 5
}' |
apify call automation-lab/peerspot-enterprise-software-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/peerspot-enterprise-software-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PeerSpot Enterprise Software Reviews Scraper",
        "description": "Extract public PeerSpot enterprise software reviews, ratings, reviewer context, pros, cons, and competitor insights.",
        "version": "0.1",
        "x-build-id": "7LhpEj2YaALETcVDa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~peerspot-enterprise-software-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-peerspot-enterprise-software-reviews-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/automation-lab~peerspot-enterprise-software-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-peerspot-enterprise-software-reviews-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/automation-lab~peerspot-enterprise-software-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-peerspot-enterprise-software-reviews-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": "🔗 PeerSpot URLs",
                        "type": "array",
                        "description": "Add public PeerSpot product review URLs (ending in -reviews) or listing pages. Listing pages are expanded to product review pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum public review records to save across all products.",
                        "default": 20
                    },
                    "maxProducts": {
                        "title": "Maximum products from listing pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "When a listing URL is used, stop after this many linked product-review pages.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```