# Amazon Review Analyzer — ReviewMeta Alternative (`khadinakbar/reviewmeta-alternative`) Actor

Analyze an Amazon review export for repeated text, similar long reviews, and concentrated rating-date patterns. Get a duplicate-aware sample average and transparent flags from the review records you supply.

- **URL**: https://apify.com/khadinakbar/reviewmeta-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 review pattern 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Amazon Review Analyzer — ReviewMeta Alternative

Analyze an Amazon review export for repeated text, similar long reviews, and concentrated rating-date patterns. Get a duplicate-aware sample average and transparent flags from the review records you supply. For product researchers, the dataset returns one aggregate pattern report for the supplied Amazon review sample.

### Workflow: put the results to work

Supply authorized review rows directly or through a dataset ID. Inspect duplicate groups and rating-date concentrations before interpreting the adjusted sample average. These are patterns within your supplied sample, not a verdict that a reviewer or product is fraudulent.

### What it does

- Reads an inline JSON review array **or** an accessible Apify dataset containing an authorized review export.
- Understands common Amazon-review field names such as `review_id`, `rating`, `review_body`, `review_date_iso`, and `is_verified_purchase`.
- Produces exactly one homogeneous `review-pattern-analysis` row with source provenance, sample coverage, rating counts, pattern signals, and method thresholds.
- Calculates a displayed sample average and an exact-duplicate-aware average. An exact text cluster contributes at most one full rating weight.
- Writes `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR` terminal outcomes to both `OUTPUT` and `RUN_SUMMARY`.

### What it does not do

- It does **not** fetch Amazon product or review pages.
- It does **not** identify a person, infer intent, or determine that any review is fake, genuine, incentivized, or deceptive.
- It does **not** replace a complete customer-review platform, browser extension, price research, seller monitoring, or historical review archive.
- It does **not** write ratings, contact reviewers, change listings, or retain review text in the output row.

### Choose the right tool

Use this Actor when you already have a review export and need a reproducible, source-linked pattern report in JSON. Choose ReviewMeta where its existing hosted consumer experience, historical analysis, extension, or proprietary workflow is available and better fits the decision.

For collection, first obtain reviews through a source you are authorized to use. Pass that export directly in `reviews`, or provide its accessible Apify `sourceDatasetId`. The Actor intentionally keeps collection separate from assessment so the evidence boundary stays clear.

### Workflow story

An analyst starts with a permitted review export for one product. They then submit the rows or the export dataset ID, compare the displayed and duplicate-aware averages, and inspect the aggregate signals with the source coverage. Next, they can export the one report row or feed it into their own review workflow alongside the original authorized source.

### How this workflow compares with ReviewMeta

| Decision | This Actor | ReviewMeta | Best fit |
|---|---|---|---|
| Scope and workflow | Aggregate analysis of caller-supplied review exports | Hosted consumer review-analysis experience | Select the scope that matches the workflow. |
| Billing and cost | Pay per event for a stored report plus platform usage | Consumer-facing offering with no matched automation allocation in the reviewed source | Review current pricing for the chosen route. |
| Same-job cost | A bounded report event is visible in the run | No like-for-like automation allocation documented | Treat cost as a documented tradeoff. |
| Effective efficiency | One report row carries method, provenance, and aggregate signals | Hosted consumer workflow | Use structured output when it fits the operating flow. |
| Integrations and automation | Apify API, datasets, schedules, and webhooks can compose the report workflow | Hosted product experience | Choose the integration surface that is required. |

ReviewMeta is a trademark of its owner. This independent Actor is not affiliated, associated, or endorsed by ReviewMeta.

### Input

Provide **exactly one** review source:

1. `reviews`: a JSON array of review objects, or
2. `sourceDatasetId`: an accessible Apify dataset ID containing review rows.

Every valid review requires a numerical `rating` from 1 to 5. These aliases are accepted:

| Meaning | Accepted fields |
|---|---|
| ID | `review_id`, `reviewId`, `id`, `idReview` |
| Rating | `rating`, `star_rating`, `starRating`, `ratingScore` |
| Text | `review_body`, `reviewDescription`, `body`, `text`, `content` |
| Title | `review_title`, `reviewTitle`, `title` |
| Date | `review_date_iso`, `reviewedAt`, `reviewDate`, `date`, `review_date` |
| Verified purchase | `is_verified_purchase`, `isVerified`, `verifiedPurchase`, `verified` |

At least three valid rows are needed to create a report. A pattern read is labeled `INSUFFICIENT_SAMPLE` if it has fewer than ten valid reviews or fewer than six dated reviews.

```json
{
  "productAsin": "B07DF46NW9",
  "productUrl": "https://www.amazon.com/dp/B07DF46NW9",
  "maxReviews": 200,
  "reviews": [
    {
      "review_id": "R1",
      "rating": 5,
      "review_title": "Useful for daily use",
      "review_body": "I used this for several weeks and found the setup simple.",
      "review_date_iso": "2026-01-15T00:00:00.000Z",
      "is_verified_purchase": true
    },
    {
      "review_id": "R2",
      "rating": 4,
      "review_body": "Good overall, although delivery took longer than expected.",
      "review_date_iso": "2026-01-18T00:00:00.000Z",
      "is_verified_purchase": true
    },
    {
      "review_id": "R3",
      "rating": 5,
      "review_body": "The item matched the listing and has held up so far.",
      "review_date_iso": "2026-01-20T00:00:00.000Z",
      "is_verified_purchase": true
    }
  ]
}
```

To analyze an existing dataset instead, omit `reviews`:

```json
{
  "sourceDatasetId": "ACCESSIBLE_DATASET_ID",
  "productAsin": "B07DF46NW9",
  "maxReviews": 200
}
```

### Output

One result means one aggregate report—not one review. The dataset output never reproduces reviewer names, profile URLs, or review text.

```json
{
  "reportType": "review-pattern-analysis",
  "product": { "asin": "B07DF46NW9", "sourceUrl": "https://www.amazon.com/dp/B07DF46NW9" },
  "sample": { "validReviewCount": 120, "datedReviewCount": 114 },
  "ratings": {
    "displayedAverage": 4.42,
    "duplicateAwareAverage": 4.31,
    "ratingCounts": { "1": 8, "2": 6, "3": 10, "4": 32, "5": 64 }
  },
  "assessment": {
    "label": "REVIEW_PATTERN_CHECK",
    "confidence": "medium",
    "explanation": "The sample contains patterns worth reading in context before relying on the displayed average."
  },
  "signals": [
    {
      "code": "EXACT_TEXT_DUPLICATION",
      "level": "review",
      "title": "Repeated normalized review text"
    }
  ]
}
```

`REVIEW_PATTERN_CHECK` means the configured sample pattern deserves contextual review. It is never a conclusion that reviews were manipulated. `NO_STRONG_PATTERN_IN_SAMPLE` only means the configured checks did not find a signal in the supplied rows; it is not an authenticity guarantee.

### Method and limitations

- **Exact duplication:** lowercases and Unicode-normalizes title/body, removes punctuation and repeated spaces, then compares text at least 24 characters long. Only these exact clusters affect the duplicate-aware average.
- **Near similarity:** reports only long-text pairs of at least 100 characters with token-set Jaccard similarity at least 0.90. These pairs never change the rating.
- **Date concentration:** reports a rolling seven-day window containing at least six dated reviews where 80% or more share the same numerical rating. A campaign, launch, seasonality, or an ordinary short sample can create this signal.
- **Unseen evidence:** deleted reviews, seller history, marketplace controls, purchases not present in the export, reviewer networks, and product-quality evidence are outside the report.

Use the report as one reason to inspect evidence, not as a purchasing, moderation, regulatory, employment, credit, insurance, or eligibility decision by itself.

### API and agent prompt

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~reviewmeta-alternative/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d @input.json
```

### Use with an AI agent through Apify MCP

> Analyze this authorized Amazon review export. Return a duplicate-aware rating, sample coverage, pattern signals, and the method limitations. Do not call any review fake and do not infer reviewer intent.

After the run, have the AI agent read the outcome and dataset report, preserve the supplied source provenance, and present the billed report cost and scope alongside the pattern assessment.

### Best results

- Use a consistent export from one product and marketplace per run.
- Prefer a substantial review sample with parseable dates for a more useful pattern comparison.
- Preserve original review IDs and dates in the source data; they improve deduplication and date coverage.
- Keep the raw export in your permitted source dataset. This Actor returns only aggregate evidence, so source-level context remains auditable outside the report.

### Builder's note

I designed this Actor around transparent restraint. Review-pattern signals are practical when their thresholds, sample boundary, and blind spots travel with the result. This design keeps the aggregate output useful while preserving the original review evidence for human context.

### Responsible use

Analyze data you are authorized to access and collect, follow applicable laws and source terms, and treat the report as a structured input to a contextual review process.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/reviewmeta-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `review-pattern-report` | Review Pattern Report | Charged once when one validated aggregate review-pattern report is stored. Invalid or too-small inputs do not create this event. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

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

Provide one exported review object per item. Each valid row needs a numeric 1–5 rating. Recognized common fields include review\_id/reviewId, rating/star\_rating/ratingScore, review\_body/reviewDescription/body, review\_date\_iso/date, and is\_verified\_purchase/isVerified. Use either this field or Source Dataset ID, not both.

## `sourceDatasetId` (type: `string`):

An accessible Apify dataset ID containing review-export rows. The Actor reads up to Max Reviews and recognizes the same common field aliases as Review JSON Array. Use either this field or Review JSON Array, not both.

## `productAsin` (type: `string`):

Optional ten-character Amazon ASIN to label the report. It is context only; the Actor does not fetch a product page.

## `productUrl` (type: `string`):

Optional canonical Amazon product URL to label the report. Only Amazon domains are accepted, and it is never fetched.

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

Maximum source rows to read. Start with 50–200 for a reviewable sample; the hard limit is 500. One stored analysis report is billed regardless of source-row count.

## Actor input object example

```json
{
  "reviews": [
    {
      "review_id": "example-1",
      "rating": 5,
      "review_title": "Sample only",
      "review_body": "Replace this illustrative record with an authorized review export before running.",
      "review_date_iso": "2026-01-01T00:00:00.000Z",
      "is_verified_purchase": true
    },
    {
      "review_id": "example-2",
      "rating": 4,
      "review_title": "Sample only",
      "review_body": "A second illustrative record. At least three valid review rows are required for a report.",
      "review_date_iso": "2026-01-02T00:00:00.000Z",
      "is_verified_purchase": true
    },
    {
      "review_id": "example-3",
      "rating": 5,
      "review_title": "Sample only",
      "review_body": "No sample output is product evidence. Use only data you are authorized to analyze.",
      "review_date_iso": "2026-01-03T00:00:00.000Z",
      "is_verified_purchase": true
    }
  ],
  "sourceDatasetId": "aBcDeFgHiJkLmNoPq",
  "productAsin": "B07DF46NW9",
  "productUrl": "https://www.amazon.com/dp/B07DF46NW9",
  "maxReviews": 200
}
```

# Actor output Schema

## `reports` (type: `string`):

Dataset rows containing aggregate rating, duplicate, similarity, date-cluster, sample-coverage, and limitation fields.

## `runOutput` (type: `string`):

Terminal outcome, result counts, and billed-event counts.

## `runSummary` (type: `string`):

Detailed terminal summary for automated branching.

# 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": [
        {
            "review_id": "example-1",
            "rating": 5,
            "review_title": "Sample only",
            "review_body": "Replace this illustrative record with an authorized review export before running.",
            "review_date_iso": "2026-01-01T00:00:00.000Z",
            "is_verified_purchase": true
        },
        {
            "review_id": "example-2",
            "rating": 4,
            "review_title": "Sample only",
            "review_body": "A second illustrative record. At least three valid review rows are required for a report.",
            "review_date_iso": "2026-01-02T00:00:00.000Z",
            "is_verified_purchase": true
        },
        {
            "review_id": "example-3",
            "rating": 5,
            "review_title": "Sample only",
            "review_body": "No sample output is product evidence. Use only data you are authorized to analyze.",
            "review_date_iso": "2026-01-03T00:00:00.000Z",
            "is_verified_purchase": true
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/reviewmeta-alternative").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": [
        {
            "review_id": "example-1",
            "rating": 5,
            "review_title": "Sample only",
            "review_body": "Replace this illustrative record with an authorized review export before running.",
            "review_date_iso": "2026-01-01T00:00:00.000Z",
            "is_verified_purchase": True,
        },
        {
            "review_id": "example-2",
            "rating": 4,
            "review_title": "Sample only",
            "review_body": "A second illustrative record. At least three valid review rows are required for a report.",
            "review_date_iso": "2026-01-02T00:00:00.000Z",
            "is_verified_purchase": True,
        },
        {
            "review_id": "example-3",
            "rating": 5,
            "review_title": "Sample only",
            "review_body": "No sample output is product evidence. Use only data you are authorized to analyze.",
            "review_date_iso": "2026-01-03T00:00:00.000Z",
            "is_verified_purchase": True,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/reviewmeta-alternative").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": [
    {
      "review_id": "example-1",
      "rating": 5,
      "review_title": "Sample only",
      "review_body": "Replace this illustrative record with an authorized review export before running.",
      "review_date_iso": "2026-01-01T00:00:00.000Z",
      "is_verified_purchase": true
    },
    {
      "review_id": "example-2",
      "rating": 4,
      "review_title": "Sample only",
      "review_body": "A second illustrative record. At least three valid review rows are required for a report.",
      "review_date_iso": "2026-01-02T00:00:00.000Z",
      "is_verified_purchase": true
    },
    {
      "review_id": "example-3",
      "rating": 5,
      "review_title": "Sample only",
      "review_body": "No sample output is product evidence. Use only data you are authorized to analyze.",
      "review_date_iso": "2026-01-03T00:00:00.000Z",
      "is_verified_purchase": true
    }
  ]
}' |
apify call khadinakbar/reviewmeta-alternative --silent --output-dataset

```

## MCP server setup

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

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/Sc8bWlGbIkmileFmS/builds/otDMqStlSJSNH4Owq/openapi.json