# HubSpot Marketplace Review Intelligence Report (`thescrapelab/hubspot-marketplace-review-intelligence-report`) Actor

Analyze public HubSpot Marketplace reviews for SaaS competitor intelligence, product feedback, sentiment, topics, and review signals.

- **URL**: https://apify.com/thescrapelab/hubspot-marketplace-review-intelligence-report.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Lead generation, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.89 / 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.

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

## HubSpot Marketplace Review Intelligence Report

![HubSpot Marketplace Review Intelligence Report thumbnail](assets/hubspot-marketplace-review-intelligence-thumbnail.png)

Turn public HubSpot App Marketplace reviews into a current-run product, customer, and competitor intelligence report. This Actor accepts HubSpot app names, search terms, or direct marketplace listing URLs, extracts visible public listing and review data, and returns summary rows plus per-review signals in an Apify Dataset.

Use it for HubSpot Marketplace review analysis, competitor research, SaaS app positioning, product feedback mining, support issue discovery, pricing objection research, and B2B SaaS voice-of-customer analysis.

### What this Actor does

- Finds public HubSpot App Marketplace listings from app names or listing URLs.
- Extracts visible public listing metadata such as app name, rating, review count, installs, categories, and listing URL where available.
- Extracts visible public review details such as rating, date, reviewer, review text, pros/cons, and developer replies where available.
- Classifies reviews into sentiment, topic, business signal, priority, summary, and competitor opportunity.
- Outputs one current-run report in the default Apify Dataset.

The Actor is stateless. It does not monitor listings, does not detect new reviews since a previous run, does not store review history, and does not use named long-term storage.

### Input

The input is intentionally simple.

```json
{
  "appInputs": ["CloudTalk"]
}
````

#### Input fields

| Field | Description |
| --- | --- |
| `appInputs` | HubSpot app names, search terms, or direct public HubSpot Marketplace listing URLs. |

The Actor defaults to analyzing up to 50 visible public reviews per app and returns app summaries plus per-review signals. Raw review text is excluded by default.

Examples for `appInputs`:

```json
[
  "CloudTalk",
  "Zapier",
  "calling software",
  "https://ecosystem.hubspot.com/marketplace/apps/cloudtalk"
]
```

### Output

Results are saved to the default Apify Dataset. The Dataset includes focused views for:

- `Report`: the best all-purpose table for quick review.
- `App summaries`: one row per app with the executive summary and top signals.
- `Review signals`: one row per analyzed review with sentiment, topic, priority, and competitor opportunity.
- `Raw reviews`: available only for API users who explicitly request raw review output.
- `Errors`: invalid or unresolved inputs.

#### App summary example

```json
{
  "itemType": "app_summary",
  "appName": "CloudTalk",
  "listingUrl": "https://ecosystem.hubspot.com/marketplace/apps/cloudtalk",
  "ratingAverage": 4.36,
  "reviewCount": 106,
  "categories": ["CALLING"],
  "reviewsAnalyzed": 50,
  "topComplaints": [],
  "topPraise": [
    {
      "topic": "VOIP system",
      "count": 8,
      "priority": "medium",
      "summary": "Customers praise setup, support, and calling workflows."
    }
  ],
  "competitorOpportunities": [
    "Competitors can differentiate with easier setup and stronger customer support."
  ],
  "executiveSummary": "CloudTalk has positive review sentiment across 50 visible reviews, with praise as the most frequent business signal."
}
```

#### Review signal example

```json
{
  "itemType": "review_signal",
  "appName": "CloudTalk",
  "listingUrl": "https://ecosystem.hubspot.com/marketplace/apps/cloudtalk",
  "rating": 5,
  "reviewDate": "Apr 1, 2026",
  "sentiment": "positive",
  "topic": "VOIP system",
  "businessSignal": "praise",
  "priority": "low",
  "summary": "CloudTalk is praised for easy setup and responsive support.",
  "competitorOpportunity": "Competitors can learn the importance of user-friendly integration and strong customer support.",
  "hasDeveloperReply": false
}
```

### Output detail

The standard output includes one app summary row per listing plus per-review intelligence rows. Raw review text is excluded by default to keep the Dataset clean and privacy-conscious.

Advanced API users can still request raw public review fields with `outputMode: "raw_reviews"`, but this is intentionally not exposed in the standard Apify input form.

### OpenRouter review analysis

If `OPENROUTER_API_KEY` is configured as an Actor secret or environment variable, the Actor uses OpenRouter to classify each deduplicated review. You can optionally set `OPENROUTER_MODEL`; otherwise the default model is used.

If OpenRouter is not configured, the Actor still runs and uses a local fallback heuristic based on review rating and keywords.

Only review fields needed for classification are sent for analysis. The Actor does not send unrelated listing metadata or maintain an analysis cache between runs.

### Common use cases

- Analyze HubSpot Marketplace reviews for a competitor app.
- Find recurring complaints in SaaS app reviews.
- Identify support, onboarding, pricing, usability, and integration issues.
- Discover competitor positioning opportunities.
- Build a current voice-of-customer report for HubSpot ecosystem apps.
- Compare review sentiment across multiple HubSpot Marketplace listings.

### API usage

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "appInputs": ["CloudTalk"],
}

run = client.actor("TheScrapeLab/hubspot-marketplace-review-intelligence-report").call(run_input=run_input)

dataset = client.dataset(run["defaultDatasetId"])
for item in dataset.iterate_items():
    print(item)
```

### Compliance and privacy

This Actor scrapes only public HubSpot App Marketplace pages supplied or resolved from the user's current input. It does not log in, does not use OAuth, does not use HubSpot private APIs, does not bypass CAPTCHAs, does not bypass access controls, and is not an official HubSpot integration.

The Actor may use the default Apify Dataset to return the current run's report. It does not create named long-term storage, does not store review history, and does not compare against previous runs.

### Limitations

- This MVP supports HubSpot App Marketplace listings only.
- It extracts visible public listing and review data available during the run.
- It does not guarantee complete historical review extraction if older reviews are hidden behind dynamic loading.
- It does not use HubSpot private APIs.
- It does not log in to HubSpot.
- It does not store cross-run review history.
- It does not detect new reviews since the previous run.
- Other marketplaces are not supported in this MVP.

# Actor input Schema

## `appInputs` (type: `array`):

Enter HubSpot app names, search terms, or direct HubSpot Marketplace listing URLs. One per line. Examples: CloudTalk, Zapier, https://ecosystem.hubspot.com/marketplace/apps/cloudtalk

## Actor input object example

```json
{
  "appInputs": [
    "CloudTalk"
  ]
}
```

# Actor output Schema

## `datasetItems` (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 = {
    "appInputs": [
        "CloudTalk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/hubspot-marketplace-review-intelligence-report").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 = { "appInputs": ["CloudTalk"] }

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/hubspot-marketplace-review-intelligence-report").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 '{
  "appInputs": [
    "CloudTalk"
  ]
}' |
apify call thescrapelab/hubspot-marketplace-review-intelligence-report --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=thescrapelab/hubspot-marketplace-review-intelligence-report",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HubSpot Marketplace Review Intelligence Report",
        "description": "Analyze public HubSpot Marketplace reviews for SaaS competitor intelligence, product feedback, sentiment, topics, and review signals.",
        "version": "0.1",
        "x-build-id": "BWvnrGFBg1Y37c8DV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~hubspot-marketplace-review-intelligence-report/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-hubspot-marketplace-review-intelligence-report",
                "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/thescrapelab~hubspot-marketplace-review-intelligence-report/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-hubspot-marketplace-review-intelligence-report",
                "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/thescrapelab~hubspot-marketplace-review-intelligence-report/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-hubspot-marketplace-review-intelligence-report",
                "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": [
                    "appInputs"
                ],
                "properties": {
                    "appInputs": {
                        "title": "Apps to analyze",
                        "type": "array",
                        "description": "Enter HubSpot app names, search terms, or direct HubSpot Marketplace listing URLs. One per line. Examples: CloudTalk, Zapier, https://ecosystem.hubspot.com/marketplace/apps/cloudtalk",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```