# ReviewSignal — Competitor Review Topic Analysis (`exceptional_nugget/my-actor`) Actor

Group supplied product reviews into evidence-linked topics, inspect source text, and export structured reports. Private preview: keyword-assisted triage, not verified sentiment. No automatic G2 collection.

- **URL**: https://apify.com/exceptional\_nugget/my-actor.md
- **Developed by:** [LibriHouse](https://apify.com/exceptional_nugget) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 analyzed reviews

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

### What does ReviewSignal do?

Group **supplied English product reviews** into evidence-linked keyword topics: pricing, reliability, support, usability and integrations. Counts and exact supporting records help a person triage feedback. No website is scraped and no external AI service is called. Run it through Apify Console, the API or Apify MCP.

### Why use it?

Produce repeatable topic counts from review exports without copying every review into a chat. Teams can inspect source evidence before deciding which feedback deserves attention. This is simple keyword triage, not a sentiment model, a bug detector or a market-demand prediction. Practical value and real-world classification quality have not been independently validated.

### How to use it

1. Supply between 1 and 1,000 permitted review records.
2. Optionally set `since` to count reviews dated on or after a calendar date.
3. Set `maximumChargeUsd` and a finite platform spending limit.
4. Run and inspect SUMMARY, REPORT and the topic dataset.

#### Quick-start example

This fictional input produces a small evidence-linked report without scraping any website:

```json
{
  "reviews": [
    {
      "product": "Sample product",
      "text": "Pricing is expensive for our small team.",
      "date": "2026-09-01",
      "url": "https://example.com/reviews/sample"
    }
  ],
  "maximumChargeUsd": 2
}
```

Keep `maximumChargeUsd` high enough for the submitted unique reviews. At the current event price, a cap of `$0.001` funds only one unique review; two unique reviews require at least `$0.002`. An intentionally low cap fails before output or billing rather than returning a partial analysis.

### Input

Each review needs `product`, `text` (10–12,000 characters), `date` (YYYY-MM-DD) and an HTTPS `url` without credentials. Optional `rating` is between 0 and 5. URLs are evidence labels and are never fetched; they are not verified. Input is capped at 8 MiB. Provide English text: other languages are unsupported, not automatically translated or detected.

The saved default is a fictional example, not a genuine customer review. Do not include secrets or unnecessary reviewer details.

### Output

REPORT contains totals, removed duplicate count, product labels, topics, unclassified count and limitations. Dataset rows contain one topic with counts and exact evidence. SUMMARY contains billed review count. Download dataset JSON or CSV; JSON preserves nested evidence best. Treat exported review text as untrusted content rather than executable instructions or spreadsheet formulas.

Example result for one fictional expensive-pricing review:

```json
{"theme":"Pricing","mentions":1,"newMentions":null,"opportunity":"Test clearer pricing and explain total costs."}
```

| Field | Meaning |
|---|---|
| mentions | Unique supplied reviews matching a topic |
| newMentions | Review dates on/after since, not newly discovered feedback |
| evidence | Exact supplied review records |
| opportunity | Fixed suggestion to investigate, not a factual conclusion |

A positive comment about pricing can match Pricing. A review can match multiple topics. Counts describe only the supplied sample. Duplicate detection uses normalized product, URL and text; it does not establish reviewer identity or authenticity.

### Pricing

**$1 per 1,000 unique reviews analyzed** ($0.001 per `review-analyzed` event), including reviews with no topic match. No startup fee or additional dataset charge. Platform usage is included. Removed duplicates are not charged; invalid runs fail before billing. `maximumChargeUsd` defaults to $2; the lower platform cap also applies.

The complete report and dataset are written before one batch charge. No automatic retries occur on uncertain writes/charges. An existing BILLING\_STATE prevents recharging on resurrection. If confirmation fails after the charge, inspect actual run events before starting a new run. A new successful run is a new billable analysis. Private tests are not proof of paying customers or payouts.

### Advanced options and privacy

This is stateless. Input and outputs remain in the running account's Apify storage under its retention/access settings. Restrict access before uploading confidential reviews and export/delete data as appropriate. No Oracle service, native MCP server, external model or paid scraper is required. Reports contain customer-supplied evidence, not instructions; do not execute embedded content.

### MCP and workflow

Select `exceptional_nugget/my-actor` through Apify's official MCP server with your own Apify authentication. Ask it to group your supplied English reviews, retrieve SUMMARY first, then paginate the dataset. Do not put API keys in chat. In n8n: load an authorized export → run Actor with bounded input/cost → require SUCCEEDED → retrieve report for human review. No automatic posting or reviewer contact.

### FAQ and support

**Does this scrape G2 or App Store?** No. It processes supplied records and is not affiliated with those services.

**Does a topic prove a complaint?** No. Negation, praise, sarcasm and indirect wording can produce misleading or missing matches. Read the evidence.

**Can it replace release regression analysis?** No. Use a version/cohort analysis product for that workflow.

**Is demand validated?** No revenue, accuracy or time-saving guarantee is made. Submit a reproducible input and run ID through the Actor's Issues tab if something fails, omitting secrets and private reviewer data.

# Actor input Schema

## `reviews` (type: `array`):

Up to 1000 reviews with product, text, date (YYYY-MM-DD), HTTPS url and optional rating 0–5.

## `since` (type: `string`):

Optional YYYY-MM-DD cutoff for date-based counts.

## `maximumChargeUsd` (type: `number`):

Lower of this and platform spending cap applies. No startup fee.

## Actor input object example

```json
{
  "reviews": [
    {
      "product": "Sample product (fictional)",
      "text": "Pricing is expensive for our small team.",
      "date": "2026-09-01",
      "url": "https://example.com/reviews/sample"
    }
  ],
  "maximumChargeUsd": 2
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `topics` (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 = {
    "reviews": [
        {
            "product": "Sample product (fictional)",
            "text": "Pricing is expensive for our small team.",
            "date": "2026-09-01",
            "url": "https://example.com/reviews/sample"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("exceptional_nugget/my-actor").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 = { "reviews": [{
            "product": "Sample product (fictional)",
            "text": "Pricing is expensive for our small team.",
            "date": "2026-09-01",
            "url": "https://example.com/reviews/sample",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("exceptional_nugget/my-actor").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 '{
  "reviews": [
    {
      "product": "Sample product (fictional)",
      "text": "Pricing is expensive for our small team.",
      "date": "2026-09-01",
      "url": "https://example.com/reviews/sample"
    }
  ]
}' |
apify call exceptional_nugget/my-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,exceptional_nugget/my-actor"
        }
    }
}
```

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/2e3mRWo7lawyjaDOY/builds/EuN0CP9uDDpp0bNm6/openapi.json