# Competitor Review Analyzer: Brand Comparison (`technicaldost/competitor-review-gap-analyzer`) Actor

Compare imported customer-feedback records by brand to surface recurring complaints, strengths and product gaps with traceable evidence. Supports mixed review datasets and explicit brand labels.

- **URL**: https://apify.com/technicaldost/competitor-review-gap-analyzer.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** AI, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$250.00 / 1,000 evidence reports

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## Competitor Review Gap Analyzer

Compare customer-feedback themes supported by at least two explicitly labeled brands. Findings are hypotheses to check against actual product capabilities, not verified competitor weaknesses.

### First run

**Preview the output:** run the input below with no records, dataset IDs or app IDs. It uses labeled synthetic records with no report-event fee. After the run, open **Markdown report** for the readable result or **JSON report** for integration.

```json
{
  "demoMode": true
}
```

The preview uses example.com source URLs and fictional feedback. It is a format demonstration, not customer or competitor research.

### Analyze your own data

Include brand on every record and supply evidence about the same topic for at least two brands. Two brands discussing unrelated topics do not create a comparison. Include text and original sourceUrl so every comparison remains reviewable.

For an existing dataset, select it with the dataset picker in the input form. The API equivalent is below; replace the placeholder before running:

```json
{
  "demoMode": false,
  "sourceType": "dataset",
  "datasetIds": [
    "YOUR_LABELED_COMPETITOR_REVIEW_DATASET_ID"
  ],
  "maxRecords": 1000,
  "maxInsights": 20
}
```

You can instead paste objects into `records`. Each record should contain `text` and its original `sourceUrl`; optional fields include `id`, `platform`, `brand`, `location`, `rating`, `date`, `likes` and `title`. Supplied sources override synthetic demo mode. Dataset reads do not rerun the collector. Any separate upstream collection workflow is outside this report price.

### What comes back

One report row in the default dataset contains an `insights` array, analyzed-record count and finding count. The output links also provide `REPORT.md` and `REPORT.json` in the key-value store. Use JSON to preserve nested evidence; use the Markdown report for review.

Comparisons include per-brand sample counts, excerpts and complaint-supported hypotheses within shared topics. Unlabeled records or topics without at least two brands cannot establish a cross-brand comparison.

### Record limits and sample comparison

`maxRecords` caps raw current records examined at 1–1,000 before deduplication and filtering. `maxInsights` caps findings at 1–30. A small or unmatched batch can return fewer findings, including zero. The fee is per delivered report, not per finding.

`previousDatasetId` remains in the input schema for compatibility. Prior-sample comparisons are implemented only in App Store Review Feature Roadmap; leave that field blank in this workflow.

### Pricing

**$0.25 per delivered report**, covering at most 1,000 current raw records. This includes analysis of inline records, existing datasets or native Apple reviews. The actor uses one `report-delivered` event and no additional dataset-row event. See the Pricing tab for the current platform price.

Synthetic previews on the imported-data workflows have no report-event fee. The App Store live sample uses actual reviews and the normal $0.25 report price.

### Method and recurring use

Analysis uses deterministic English phrase/rating rules and text grouping; no generative AI model is called. Scores and draft actions are research aids. Sarcasm, negation, uncommon phrasing and multilingual text can be misclassified. Inspect supporting evidence before acting. Topics can overlap, so their percentages must not be added together. Samples do not establish market-wide demand, product capabilities or future business results.

Use the Actor API or Apify MCP with the same input schema. Imported datasets are snapshots; provide fresh source data for repeated analysis. This actor does not directly scrape YouTube, Reddit or Google Maps or start third-party collectors. No external model key is required.

### Local run

Requires Node.js 22 or newer. Run `npm ci`, then `npm start`. The Dockerfile uses `apify/actor-node:22`.

# Actor input Schema

## `demoMode` (type: `boolean`):

With records, datasetIds and appIds empty, use labeled synthetic records with no report-event fee. Any supplied source overrides this preview and uses the normal report price.

## `records` (type: `array`):

Include brand on every record and supply evidence about the same topic for at least two brands. Two brands discussing unrelated topics do not create a comparison. Include text and original sourceUrl so every comparison remains reviewable. Supported optional fields include id, date, rating and likes.

## `datasetIds` (type: `array`):

Select your existing source dataset from the picker. It is read with READ permission; its collector is not rerun. Competitor comparisons require brand labels on records and a shared topic.

## `sourceType` (type: `string`):

Use imported datasets or inline records for this workflow. Native Apple review feeds are an optional shared input adapter; they do not collect reviews from other platforms.

## `appIds` (type: `array`):

Optional Apple feed adapter only; not needed for this workflow’s imported data. Numeric Apple App Store app IDs, as strings. Uses public customer-review feeds; feed availability and historical coverage vary by app and storefront.

## `country` (type: `string`):

Optional Apple feed adapter only; not needed for this workflow’s imported data. Two-letter Apple storefront country code. Only used for app-store collection; analysis rules are optimized for English text.

## `maxPages` (type: `integer`):

Optional Apple feed adapter only; not needed for this workflow’s imported data. Maximum review-feed pages requested per app; the source can return fewer pages. The overall record cap still applies.

## `maxRecords` (type: `integer`):

Maximum raw source records read/examined across this run, before deduplication and filtering. Launch limit is 1,000. This is not a guarantee of 1,000 unique reviews or insights.

## `maxInsights` (type: `integer`):

Upper limit on ranked findings inside the single report. Results can be fewer when the supplied evidence does not support additional findings.

## `brand` (type: `string`):

Optional label for the business/product under study. For competitor comparison, provide a brand on each record to preserve distinct groups; service records can also provide location.

## `previousDatasetId` (type: `string`):

App Roadmap comparison only. This workflow does not produce prior-sample comparisons; leave this field blank. Kept for input compatibility.

## Actor input object example

```json
{
  "demoMode": true,
  "sourceType": "dataset",
  "country": "us",
  "maxPages": 2,
  "maxRecords": 1000,
  "maxInsights": 20
}
```

# Actor output Schema

## `report` (type: `string`):

No description

## `markdown` (type: `string`):

No description

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/competitor-review-gap-analyzer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/competitor-review-gap-analyzer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call technicaldost/competitor-review-gap-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,technicaldost/competitor-review-gap-analyzer"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3GMwrAwZ1D4zAvcxv/builds/oWtdqW3b7LRD8RfFz/openapi.json