# SmartCustomer Business Reviews Scraper (`automation-lab/smartcustomer-business-reviews`) Actor

Extract public SmartCustomer business reviews with text, titles, ratings, dates, public author references and business reputation snapshots from supplied business URLs.

- **URL**: https://apify.com/automation-lab/smartcustomer-business-reviews.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.36 / 1,000 review extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## SmartCustomer Business Reviews Scraper

Export public **SmartCustomer reviews** from business review URLs for reputation analysis and competitor comparison. Each dataset row contains one review, its public source link, and the business reputation aggregates observed on that page.

This Actor is for brand analysts, customer-experience teams and researchers who need repeatable review snapshots rather than manual copy-and-paste. It does not log in, contact reviewers, submit reviews or obtain private account data.

### Why use this Actor?

- Keep source review links alongside text so findings remain traceable.
- Export numeric ratings and normalized publication dates for analysis.
- Compare individual feedback with the business aggregate rating and review count.
- Set a global review limit and a per-business page limit to bound each collection.
- Process several supplied businesses in a predictable input order.

The Actor reads public structured data without downloading images or opening reviewer profiles. It does not promise a complete archive, a newest-first sort, or real-time alerts.

### Who is it for?

Brand analysts can compare customer feedback across businesses. Customer-experience teams can group recurring complaints, and researchers can retain traceable snapshots for downstream analysis.

### Getting started

1. Open a public SmartCustomer business review page.
2. Copy its HTTPS URL, such as `https://www.smartcustomer.com/reviews/amazon.com`.
3. Add it to **Business review URLs**.
4. Choose the maximum number of reviews and pages per business.
5. Start the Actor and open the default dataset when it finishes.
6. Export JSON, CSV, Excel or another format supported by Apify datasets.

The default input collects up to 20 unique reviews from the first business. Collection always starts at page one, including when the supplied URL has a page query.

### Input

```json
{
  "startUrls": [{"url": "https://www.smartcustomer.com/reviews/amazon.com"}],
  "maxItems": 20,
  "maxPagesPerBusiness": 10
}
```

| Field | Default | Meaning |
| --- | --- | --- |
| `startUrls` | Required | 1–20 public SmartCustomer business-review URLs. Duplicate businesses are merged. |
| `maxItems` | 20 | Global maximum of unique reviews, from 1 to 10000. Not a per-business quota. |
| `maxPagesPerBusiness` | 10 | Maximum pages fetched for each business, from 1 to 100. |

The Actor processes URLs sequentially. A large first business can consume the global result limit before later businesses are visited. Run businesses separately if each needs an equal quota.

Only `https://smartcustomer.com/reviews/<business>` and the `www` equivalent are accepted. A valid `page` parameter is reset to page one. Anchors, rating filters, search parameters, unsupported domains and nested review paths are rejected. URL entries support only `url` and optional `method: GET`; custom headers, payload, userData and remote URL lists are rejected. Zero or unlimited limits are unsupported.

### Extracted data

| Field | Meaning |
| --- | --- |
| `reviewId` | Review anchor identifier, scoped to the business. |
| `reviewUrl` | Public review reference with anchor. |
| `title` | Review headline, or null. |
| `text` | Review body supplied in public structured data. |
| `rating` | Numeric review rating from 1 to 5. |
| `date` | Publication date as YYYY-MM-DD, or null. |
| `authorName` | Public reviewer display name, or null. |
| `authorUrl` | Public author reference, or null; profile not fetched. |
| `businessName` | Business display name. |
| `businessUrl` | Canonical SmartCustomer business-review URL. |
| `businessWebsite` | Source-provided business website reference, or null; not fetched. |
| `businessRating` | Aggregate business rating at collection time, or null. |
| `businessReviewCount` | Aggregate source review count, not exported row count, or null. |
| `sourcePage` | Page from which the review was extracted. |
| `scrapedAt` | UTC collection timestamp. |

Business aggregates repeat on each review row; they have no separate event charge. Do not sum aggregate review counts across rows. Use one snapshot per business when preparing reputation reports.

### Output example

This anonymized example follows the shape verified on live public business pages:

```json
{
  "reviewId": "12345",
  "reviewUrl": "https://www.smartcustomer.com/reviews/example.com#12345",
  "title": "Helpful service",
  "text": "The service was helpful.",
  "rating": 4,
  "date": "2026-10-01",
  "authorName": "Example A.",
  "authorUrl": "https://www.smartcustomer.com/users/exampleuser",
  "businessName": "Example",
  "businessUrl": "https://www.smartcustomer.com/reviews/example.com",
  "businessWebsite": "https://example.com/",
  "businessRating": 3.5,
  "businessReviewCount": 1234,
  "sourcePage": "https://www.smartcustomer.com/reviews/example.com",
  "scrapedAt": "2026-10-25T15:00:00.000Z"
}
```

### How much does it cost to extract SmartCustomer reviews?

Pay-per-event pricing charges a one-time **$0.005 start fee** plus a fee for each emitted review. The BRONZE review price is **$0.0006**. Prices vary by Apify pricing tier; check the current Pricing tab for your account.

| Tier | Price per review |
| --- | --- |
| FREE | $0.00069 |
| BRONZE | $0.0006 |
| SILVER | $0.000468 |
| GOLD | $0.00036 |
| PLATINUM | $0.00036 |
| DIAMOND | $0.00036 |

Estimated BRONZE invoice totals, including one start fee:

| Reviews collected | Estimated total |
| --- | --- |
| 20 | $0.017 |
| 100 | $0.065 |
| 1000 | $0.605 |

These examples assume the source and configured page cap provide that many reviews. The start fee can apply when a source request later fails. Invalid input is rejected before the start event. Duplicate and malformed records are not charged as review output.

### Pagination and coverage

The Actor follows numbered next-page links for the same business only. Collection stops at the global review limit, per-business page cap, source exhaustion, billing limit or platform timeout. It preserves the source's default ordering, which may include featured or older reviews; it does not guarantee chronological completeness.

Deduplication uses the full review URL within a run. For recurring snapshots, deduplicate across runs by `businessUrl` and `reviewId`, and keep `scrapedAt` to track observation time. This Actor does not maintain a historical database or detect changes for you.

### Integrations

- **Google Sheets or Excel:** export review rows to a spreadsheet and build rating/date pivot tables.
- **Webhooks and Make:** trigger downstream processing after a successful run.
- **Data warehouses:** retain JSON snapshots keyed by review URL for recurring comparisons.
- **Sentiment analysis:** analyze collected text downstream, retaining source links for auditability.
- **Apify schedules:** schedule repeated snapshots; compare results in your own pipeline. Scheduling is not built-in alerting.

### API usage

Replace `YOUR_APIFY_TOKEN` with your own Apify token. Avoid sharing authenticated URLs or tokens.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~smartcustomer-business-reviews/run-sync-get-dataset-items' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.smartcustomer.com/reviews/amazon.com"}],"maxItems":20}'
```

JavaScript with `apify-client`:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/smartcustomer-business-reviews').call({
  startUrls: [{ url: 'https://www.smartcustomer.com/reviews/amazon.com' }],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });
console.log(items);
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/smartcustomer-business-reviews').call(run_input={
    'startUrls': [{'url': 'https://www.smartcustomer.com/reviews/amazon.com'}],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items(limit=20).items
print(items)
```

For larger exports, start asynchronously, retain the run ID, wait for terminal success and page through its dataset. A run identifier is metadata, not the review output.

### Use with MCP

Select this stable Actor subset in an MCP-capable client:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/smartcustomer-business-reviews'
```

Equivalent configuration for Claude Desktop, Cursor, and VS Code (adapt to the client's MCP configuration format):

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/smartcustomer-business-reviews"
    }
  }
}
```

Authenticate using your client's supported Apify setup. Discover actual tools and input schemas using scoped `tools/list`; Actor selection also adds run, dataset, key-value-store and abort helpers. Discovery alone does not authorize execution.

Example prompt (execute only when authorized): “Collect up to 20 reviews from this SmartCustomer business page and summarize recurring service concerns, linking each finding to its source review.”

Start once and retain the returned run/storage IDs. If nonterminal, follow the same run with bounded backoff (2, 4, 8 seconds, capped at 10) for a total deadline of 120 seconds; configure request timeouts above the chosen server wait. On client timeout recover the known run, not a duplicate. If the run ID is unknown, report uncertainty. At the deadline report pending with the run ID. Treat rows from failed runs as partial.

After success, fetch dataset pages of 20 source rows, at most 100 rows and 64 KiB serialized UTF-8 content admitted to model context. Enforce that budget host-side before injection, report oversized omissions and the next source offset, and keep complete exports outside the model. Clients unable to intercept oversized responses cannot guarantee a hard byte ceiling. These are consumer limits, not Actor collection defaults. No universal token-savings claim is made.

### Limitations and troubleshooting

- Missing or changed structured data, challenge pages and unexpected HTTP errors fail the run instead of masquerading as a valid empty export.
- A naturally empty profile is accepted only when the source explicitly reports zero reviews.
- Network errors, HTTP 429 and temporary server errors receive bounded retries. No paid proxy or browser fallback is enabled.
- Source errors can leave partial dataset rows. Check the final run status before treating an export as complete.
- A page cap or result cap intentionally truncates coverage without implying every source review was collected.
- Photos, business replies, account actions, category search and custom sorting are not supported.

If fewer reviews appear than expected, inspect both limits and the source's public page coverage. The aggregate count may include reviews not available through the pages collected. If a source page is unavailable, verify the business URL manually before retrying.

### Legality

Use this Actor only for purposes you are authorized to perform. It uses Apify standard terms, not custom end-user terms. Review the source's terms and applicable law before collection or redistribution.

### Privacy and responsible use

Use public review data responsibly and comply with applicable law, source terms and your own obligations. Public availability does not grant unrestricted rights to republish personal information. Do not use reviewer references for harassment or unsolicited contact. This Actor is not affiliated with SmartCustomer.

Runtime extraction uses no AI or external model service. Results and logs remain in your Apify run storage until you delete them or your account's retention policy removes them. No cross-run review cache is maintained. Manage storage deletion in Apify Console; contact us through the Actor's Issues tab for support.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days.

### FAQ

**Does it collect private profiles or contact information?** No. It reads public review pages and records public author references without visiting profiles.

**Does it always return the latest reviews?** No. The source controls the default order, and featured reviews can appear ahead of newer reviews.

**Can I monitor changes automatically?** Schedule repeated runs through Apify and compare datasets downstream. The Actor itself does not store cross-run state or send alerts.

**Why does a run fail with partial results?** An upstream request or structured-data validation failed after earlier pages were saved. Use the rows as partial evidence, not a complete successful export.

### Related Actors

For other business-review corpora, see [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) and [PissedConsumer Company Reviews Scraper](https://apify.com/automation-lab/pissedconsumer-company-reviews-scraper). These are complementary sources, not SmartCustomer coverage or automatic fallbacks.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/smartcustomer-business-reviews/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Provide 1–20 HTTPS smartcustomer.com/reviews/<business> URLs. Only url and optional method GET are supported; headers, payload, userData and remote URL lists are rejected. Duplicate businesses are merged. Collection always starts at page one; a page query is reset. Anchors, search, rating filters and other URL parameters are rejected. Businesses are processed in input order until the global result limit.

## `maxItems` (type: `integer`):

Global maximum of unique review records across all businesses, after deduplication. Default 20; range 1–10000. Zero/unlimited is unsupported. Collection may stop earlier at source exhaustion, per-business page cap, timeout or billing limit. No date/rating filters are applied.

## `maxPagesPerBusiness` (type: `integer`):

Fetch at most this many public pages for each business, starting at page one. Default 10; range 1–100. Global maxItems can stop collection earlier. This cap limits coverage, not reviews per page; upstream ordering and page sizes may vary.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.smartcustomer.com/reviews/amazon.com"
    }
  ],
  "maxItems": 20,
  "maxPagesPerBusiness": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing the collected reviews.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.smartcustomer.com/reviews/amazon.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/smartcustomer-business-reviews").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 = { "startUrls": [{ "url": "https://www.smartcustomer.com/reviews/amazon.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/smartcustomer-business-reviews").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 '{
  "startUrls": [
    {
      "url": "https://www.smartcustomer.com/reviews/amazon.com"
    }
  ]
}' |
apify call automation-lab/smartcustomer-business-reviews --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/smartcustomer-business-reviews"
        }
    }
}
```

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/vEBpteTRiJQYaCxru/builds/a39yu5CmqQixsRnQ1/openapi.json