# B2B Competitor Review Battlecard Monitor (`geneius/b2b-competitor-review-battlecard-monitor`) Actor

Convert Trustpilot, G2, Capterra, or SaaS review records into battlecard-ready objections, strengths, snippets, and sales actions.

- **URL**: https://apify.com/geneius/b2b-competitor-review-battlecard-monitor.md
- **Developed by:** [Gene](https://apify.com/geneius) (community)
- **Categories:** AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

### B2B Competitor Review Battlecard Monitor

Convert Trustpilot, G2, Capterra, and other B2B review records into **battlecard-ready objections, competitor strengths, review snippets, and sales actions**.

This Actor is for product marketing, sales enablement, RevOps, and agencies that already collect competitor reviews but need a repeatable way to turn them into competitive intelligence.

<!-- revenue-machine:workflow-hub:start -->
### Workflow Hub

See the public [review intelligence workflow](https://geneiusk.github.io/apify-actor-powerhouse-hub/review-intelligence.html) for the scraper dataset -> analyzer path, demo story, and links across the review-intelligence Actors. Product marketing teams can start from the [competitor review battlecards use case](https://geneiusk.github.io/apify-actor-powerhouse-hub/competitor-review-battlecards.html). For the first run, use the [B2B competitor battlecard demo script](https://geneiusk.github.io/apify-actor-powerhouse-hub/b2b-competitor-battlecard-demo.html). The [proof GIF](https://geneiusk.github.io/apify-actor-powerhouse-hub/assets/b2b-competitor-battlecard-proof.gif) shows mixed competitor reviews becoming an objection-handling battlecard row.
<!-- revenue-machine:workflow-hub:end -->

### What You Learn

- Which competitor reviews mention pricing, support, reliability, integrations, implementation, ease of use, or missing features
- Which negative reviews should become battlecard objection rows
- Which positive reviews reveal competitor strengths your sales team should counter
- Which snippets are worth saving for enablement
- What action to take for each competitor review

### Use Cases

- Monthly sales battlecard refreshes
- Competitor-review monitoring for SaaS categories
- Pricing objection mining
- Churn and switching-trigger detection
- Product marketing research from Trustpilot, G2, Capterra, and similar datasets

### Input

Provide reviews inline or pass an Apify `datasetId` from another review scraper.

```json
{
  "defaultCompetitor": "Acme CRM",
  "productCategory": "CRM",
  "reviews": [
    {
      "competitorName": "Acme CRM",
      "rating": 2,
      "text": "The pricing got expensive at renewal and support took days to respond.",
      "source": "Trustpilot"
    }
  ],
  "maxReviews": 100
}
````

### Output

Each dataset item is one analyzed competitor review:

```json
{
  "status": "succeeded",
  "recordIndex": 1,
  "billingEventName": "battlecard-review-analyzed",
  "competitorName": "Acme CRM",
  "productCategory": "CRM",
  "sourceName": "Trustpilot",
  "rating": 2,
  "sentimentLabel": "negative",
  "objectionThemes": ["pricing_objection", "support"],
  "urgencyScore": 75,
  "battlecardSnippet": "The pricing got expensive at renewal and support took days to respond.",
  "salesAction": "Position against Acme CRM with transparent pricing, ROI proof, and renewal-risk messaging."
}
```

The run also writes a `SUMMARY` key-value-store record with objection and praise theme counts.

### FAQ

#### Does this scrape review sites?

No. It analyzes B2B review records you provide inline or through an Apify dataset from another scraper. It is designed to turn review text into battlecard material.

#### What input do I need for the first run?

Use the Store example with `defaultCompetitor`, `productCategory`, and a few review records. Ratings and source labels help, but review text is the key field.

#### What do I get back?

One dataset item per analyzed review, including objection themes, urgency, battlecard snippet, and a suggested sales action. The run also writes a `SUMMARY` record.

#### Who is this for?

Product marketing, sales enablement, RevOps, and agencies that need recurring competitor-review intelligence rather than raw review exports.

#### When is it commercially chargeable?

The configured paid event is `battlecard-review-analyzed` at `$0.03`, scheduled for 2026-05-26T21:05:10Z. Run a small paid smoke after activation before promoting high-volume use.

### Pricing

Default monetization model: pay per event.

Recommended chargeable event:

- Event name: `battlecard-review-analyzed`
- Event meaning: one successfully analyzed competitor review
- Store price: `$0.03` per analyzed review
- Pricing activation: scheduled for `2026-05-26T21:05:10Z`

Successful rows are pushed only after the charge path allows the event. Run a paid smoke after the scheduled activation time before promoting the listing.

### Limitations

- This MVP analyzes review records; it does not scrape Trustpilot, G2, or Capterra directly.
- Source schemas vary. The Actor recognizes common fields such as `text`, `reviewText`, `rating`, `competitorName`, `productName`, `source`, and `date`.
- The taxonomy is deterministic and explainable, built for monitoring and sales workflows.

### Automation And Agent Use

- Run a review scraper first, then pass its dataset ID to this Actor.
- Schedule monthly battlecard refreshes by competitor.
- Send pricing/support objections to a CRM note, Slack channel, or battlecard document.
- Export `battlecardSnippet` and `salesAction` to Google Sheets for sales enablement.

### Local Development

```bash
python3 -m pip install -r requirements.txt
ACTOR_TEST_PAY_PER_EVENT=true apify run --purge --input-file examples/smoke-input.json
```

# Actor input Schema

## `defaultCompetitor` (type: `string`):

Fallback competitor or product name when a review record does not include one.

## `productCategory` (type: `string`):

Category used in the output, such as CRM, help desk, data platform, or accounting software.

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

Optional B2B review records. Each record should include review text and may include competitorName, productName, rating, source, date, or URL.

## `datasetId` (type: `string`):

Optional Apify dataset ID containing review records from another Actor.

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

Safety cap for analyzed reviews in one run.

## `datasetItemLimit` (type: `integer`):

Maximum number of records to load from the source dataset.

## `includeRawReview` (type: `boolean`):

When enabled, dataset items include the original review text.

## `failOnInvalidRecord` (type: `boolean`):

When enabled, the Actor fails on the first invalid review record instead of returning partial error records.

## Actor input object example

```json
{
  "defaultCompetitor": "Acme CRM",
  "productCategory": "CRM",
  "reviews": [
    {
      "competitorName": "Acme CRM",
      "rating": 2,
      "text": "The pricing got expensive at renewal and support took days to respond.",
      "source": "Trustpilot"
    }
  ],
  "maxReviews": 100,
  "datasetItemLimit": 100,
  "includeRawReview": true,
  "failOnInvalidRecord": false
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items with one row per analyzed competitor review, including objection themes, praise themes, urgency, snippet, and sales action.

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

Run-level summary with analyzed review count, failures, charge event name, and theme counts.

# 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 = {
    "defaultCompetitor": "Acme CRM",
    "productCategory": "CRM",
    "reviews": [
        {
            "competitorName": "Acme CRM",
            "rating": 2,
            "text": "The pricing got expensive at renewal and support took days to respond.",
            "source": "Trustpilot"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("geneius/b2b-competitor-review-battlecard-monitor").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 = {
    "defaultCompetitor": "Acme CRM",
    "productCategory": "CRM",
    "reviews": [{
            "competitorName": "Acme CRM",
            "rating": 2,
            "text": "The pricing got expensive at renewal and support took days to respond.",
            "source": "Trustpilot",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("geneius/b2b-competitor-review-battlecard-monitor").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 '{
  "defaultCompetitor": "Acme CRM",
  "productCategory": "CRM",
  "reviews": [
    {
      "competitorName": "Acme CRM",
      "rating": 2,
      "text": "The pricing got expensive at renewal and support took days to respond.",
      "source": "Trustpilot"
    }
  ]
}' |
apify call geneius/b2b-competitor-review-battlecard-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=geneius/b2b-competitor-review-battlecard-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Competitor Review Battlecard Monitor",
        "description": "Convert Trustpilot, G2, Capterra, or SaaS review records into battlecard-ready objections, strengths, snippets, and sales actions.",
        "version": "0.1",
        "x-build-id": "w0WH9S1RgV7GyP2qZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/geneius~b2b-competitor-review-battlecard-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-geneius-b2b-competitor-review-battlecard-monitor",
                "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/geneius~b2b-competitor-review-battlecard-monitor/runs": {
            "post": {
                "operationId": "runs-sync-geneius-b2b-competitor-review-battlecard-monitor",
                "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/geneius~b2b-competitor-review-battlecard-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-geneius-b2b-competitor-review-battlecard-monitor",
                "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",
                "properties": {
                    "defaultCompetitor": {
                        "title": "Default competitor",
                        "type": "string",
                        "description": "Fallback competitor or product name when a review record does not include one."
                    },
                    "productCategory": {
                        "title": "Product category",
                        "type": "string",
                        "description": "Category used in the output, such as CRM, help desk, data platform, or accounting software.",
                        "default": "B2B software"
                    },
                    "reviews": {
                        "title": "Inline review records",
                        "minItems": 1,
                        "type": "array",
                        "description": "Optional B2B review records. Each record should include review text and may include competitorName, productName, rating, source, date, or URL."
                    },
                    "datasetId": {
                        "title": "Source dataset ID",
                        "minLength": 1,
                        "type": "string",
                        "description": "Optional Apify dataset ID containing review records from another Actor."
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Safety cap for analyzed reviews in one run.",
                        "default": 100
                    },
                    "datasetItemLimit": {
                        "title": "Dataset item limit",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to load from the source dataset.",
                        "default": 100
                    },
                    "includeRawReview": {
                        "title": "Include raw review text",
                        "type": "boolean",
                        "description": "When enabled, dataset items include the original review text.",
                        "default": true
                    },
                    "failOnInvalidRecord": {
                        "title": "Fail on invalid record",
                        "type": "boolean",
                        "description": "When enabled, the Actor fails on the first invalid review record instead of returning partial error records.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
