# Sitejabber Reviews Scraper (`automation-lab/sitejabber-reviews-scraper`) Actor

Scrape public Sitejabber reviews, ratings, review text, reviewer names, dates, and aggregate metrics by URL or domain.

- **URL**: https://apify.com/automation-lab/sitejabber-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## Sitejabber Reviews Scraper

Scrape public Sitejabber / SmartCustomer business reviews, ratings, review text, reviewer names, review dates, and business-level rating totals from review pages or plain domains.

### What does Sitejabber Reviews Scraper do?

Sitejabber Reviews Scraper extracts public review data from Sitejabber business pages.

It is built for recurring reputation monitoring, competitor research, marketplace analysis, and customer sentiment tracking.

You can enter Sitejabber review URLs such as `https://www.sitejabber.com/reviews/amazon.com` or plain domains such as `amazon.com`.

The actor normalizes those inputs, paginates the public review pages, and saves one dataset row per review.

### Who is it for?

🧑‍💼 Reputation management agencies can monitor new complaints and star changes for client brands.

🛒 Ecommerce operators can compare their Sitejabber feedback against marketplace competitors.

📊 Analysts can collect review text for sentiment, support, logistics, or product-quality research.

🏢 Brand teams can build recurring review archives outside Trustpilot and Google Maps.

### Why use this actor?

Sitejabber is a review source that many broad reputation stacks miss.

This actor is HTTP-first and lightweight, so small monitoring runs are fast and inexpensive.

It returns a flat review dataset that is easy to export to CSV, Excel, Google Sheets, a database, or an LLM pipeline.

### What data can you extract?

| Field | Description |
| --- | --- |
| `businessDomain` | Domain from the Sitejabber review page |
| `businessName` | Public business display name |
| `businessWebsite` | Website listed in structured data |
| `aggregateRating` | Overall business rating |
| `totalReviewCount` | Total reviews reported by the page |
| `reviewId` | Review identifier when derivable from the review URL |
| `reviewUrl` | Public review URL |
| `rating` | Individual review star rating |
| `title` | Review headline |
| `text` | Review body text |
| `reviewerName` | Public reviewer name |
| `reviewerProfileUrl` | Public reviewer profile URL when available |
| `reviewDate` | Review publication date |
| `pageNumber` | Page number where the review was found |
| `scrapedAt` | Timestamp of the scrape |

### How much does it cost to scrape Sitejabber reviews?

The actor uses pay-per-event pricing.

There is a small run-start charge and a per-review charge for each dataset item saved.

A prefilled run is intentionally small so you can test the output before scaling up.

For large recurring jobs, increase `maxReviewsPerBusiness` after verifying the first result sample.

### How to scrape Sitejabber reviews

1. Open the actor on Apify.
2. Add one or more Sitejabber review URLs or company domains.
3. Choose the maximum reviews per business.
4. Pick a sort order if needed.
5. Start the run.
6. Download results from the default dataset.

### Input configuration

#### Sitejabber review URLs

Use `startUrls` for full review page URLs.

Example:

```json
[
  { "url": "https://www.sitejabber.com/reviews/amazon.com" }
]
````

#### Company domains

Use `domains` when you only have company domains.

Example:

```json
["amazon.com", "ebay.com"]
```

#### Maximum reviews per business

`maxReviewsPerBusiness` controls the cap for each business.

Use a low value for smoke tests and a higher value for production exports.

#### Sort order

The actor supports the public Sitejabber sort query values exposed by the website.

Use the default `published` sort for monitoring new reviews.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.sitejabber.com/reviews/amazon.com" }
  ],
  "domains": [],
  "maxReviewsPerBusiness": 40,
  "sort": "published"
}
```

### Example output

```json
{
  "businessDomain": "amazon.com",
  "businessName": "Amazon",
  "aggregateRating": 2.5,
  "totalReviewCount": 11109,
  "rating": 1,
  "title": "Order problem",
  "text": "The review text appears here...",
  "reviewerName": "Jane D.",
  "reviewDate": "2026-05-14",
  "reviewUrl": "https://www.smartcustomer.com/reviews/amazon.com#review-123456",
  "pageNumber": 1,
  "scrapedAt": "2026-05-27T00:00:00.000Z"
}
```

### Tips for better results

✅ Start with one domain and 20 to 40 reviews.

✅ Use `published` sort for monitoring workflows.

✅ Use domains when your source list comes from a CRM or spreadsheet.

✅ Store `scrapedAt` with your exports so you can compare snapshots over time.

### Common use cases

- Daily brand reputation monitoring
- Ecommerce competitor review tracking
- Customer complaint clustering
- Negative-review alerting
- Marketplace trust research
- LLM sentiment analysis datasets
- Support and fulfillment issue discovery

### Integrations

Connect the dataset to Google Sheets for daily reporting.

Send output to a webhook and alert Slack when low-star reviews appear.

Export JSON to a data warehouse and join it with sales, returns, or support metrics.

Feed review text into an LLM to classify complaint categories and urgency.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sitejabber-reviews-scraper').call({
  domains: ['amazon.com'],
  maxReviewsPerBusiness: 20,
  sort: 'published'
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/sitejabber-reviews-scraper').call(run_input={
    'domains': ['amazon.com'],
    'maxReviewsPerBusiness': 20,
    'sort': 'published',
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~sitejabber-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"domains":["amazon.com"],"maxReviewsPerBusiness":20,"sort":"published"}'
```

### MCP usage

Use the Apify MCP server with Claude Code, Claude Desktop, Cursor, or VS Code to call this actor from your AI workspace.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/sitejabber-reviews-scraper
```

Claude Code setup:

```bash
claude mcp add apify-sitejabber --transport http "https://mcp.apify.com/?tools=automation-lab/sitejabber-reviews-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-sitejabber": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sitejabber-reviews-scraper"
    }
  }
}
```

Cursor setup:

Add the same MCP URL in Cursor's MCP server settings as an HTTP server named `apify-sitejabber`.

VS Code setup:

Add the same MCP URL in your VS Code MCP configuration as an HTTP server named `apify-sitejabber`.

Example prompts:

- "Scrape 20 newest Sitejabber reviews for amazon.com and summarize the top complaints."
- "Compare recent Sitejabber ratings for these ecommerce domains."
- "Find one-star review themes from the Sitejabber dataset."

### Data quality notes

The actor extracts structured data that Sitejabber publishes in the initial HTML.

Some optional fields may be null if the public page does not expose them in parseable structured data.

Review availability and pagination depend on the public website.

### Limitations

The actor does not log in.

It does not bypass private pages or account-only content.

It focuses on business review pages, not category discovery.

### FAQ

#### Why did I get fewer reviews than requested?

The page may have fewer public reviews for that sort/filter, or Sitejabber may stop pagination for that business.

Try a lower cap first, confirm the business page exists, then increase the limit.

#### Can I enter only a domain?

Yes. Enter `example.com` in `domains` and the actor converts it to a Sitejabber review page.

#### Why are helpful counts null?

The v0.1 scraper uses public structured HTML. Helpful counts are only emitted when they are available in parseable public data.

### Legality and responsible use

This actor extracts publicly available information.

You are responsible for using the data in compliance with applicable laws, platform terms, and privacy requirements.

Avoid collecting data that you do not need, and respect deletion or compliance requests in your downstream systems.

### Related scrapers

- https://apify.com/automation-lab/trustpilot-scraper
- https://apify.com/automation-lab/trustpilot-reviews-scraper
- https://apify.com/automation-lab/google-maps-reviews-scraper
- https://apify.com/automation-lab/yelp-scraper

### Changelog

#### 0.1

Initial Sitejabber review extraction from public review pages.

### Support

If a public Sitejabber review page no longer parses correctly, open an Apify issue with the input URL and a recent run link.

### Output schema stability

The actor keeps reserved nullable fields for reviewer location, helpful count, and business reply metadata so future improvements can fill them without breaking downstream exports.

### Performance

The scraper is HTTP-only and does not launch a browser.

This keeps memory low and makes the actor suitable for frequent monitoring jobs.

### Best practices for recurring monitoring

Run the actor daily or weekly with `published` sort.

Store review URLs or review IDs in your database.

Deduplicate downstream by `reviewUrl` or by business domain plus review date and text.

### Feedback workflows

Use the dataset to route low-star reviews to support, product, logistics, or marketplace teams.

Combine `rating`, `text`, and `reviewDate` for alert rules.

Keep the raw dataset for auditability before applying sentiment labels.

# Actor input Schema

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

One or more Sitejabber or SmartCustomer review page URLs, such as https://www.sitejabber.com/reviews/amazon.com.

## `domains` (type: `array`):

Optional plain domains to convert to Sitejabber review pages, for example amazon.com or ebay.com.

## `maxReviewsPerBusiness` (type: `integer`):

Maximum number of reviews to save for each business/domain. Keep this low for the first run, then increase for monitoring jobs.

## `sort` (type: `string`):

Optional public Sitejabber sort query. The default follows the website default order.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.sitejabber.com/reviews/amazon.com"
    }
  ],
  "domains": [
    "amazon.com"
  ],
  "maxReviewsPerBusiness": 20,
  "sort": "published"
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.sitejabber.com/reviews/amazon.com"
        }
    ],
    "domains": [
        "amazon.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sitejabber-reviews-scraper").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.sitejabber.com/reviews/amazon.com" }],
    "domains": ["amazon.com"],
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/sitejabber-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sitejabber Reviews Scraper",
        "description": "Scrape public Sitejabber reviews, ratings, review text, reviewer names, dates, and aggregate metrics by URL or domain.",
        "version": "0.1",
        "x-build-id": "Pr1xLo9bAqx1Up4gt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sitejabber-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sitejabber-reviews-scraper",
                "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/automation-lab~sitejabber-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sitejabber-reviews-scraper",
                "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/automation-lab~sitejabber-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sitejabber-reviews-scraper",
                "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": {
                    "startUrls": {
                        "title": "Sitejabber review URLs",
                        "type": "array",
                        "description": "One or more Sitejabber or SmartCustomer review page URLs, such as https://www.sitejabber.com/reviews/amazon.com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domains": {
                        "title": "Company domains",
                        "type": "array",
                        "description": "Optional plain domains to convert to Sitejabber review pages, for example amazon.com or ebay.com.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerBusiness": {
                        "title": "Maximum reviews per business",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each business/domain. Keep this low for the first run, then increase for monitoring jobs.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "published",
                            "rating_high",
                            "rating_low"
                        ],
                        "type": "string",
                        "description": "Optional public Sitejabber sort query. The default follows the website default order.",
                        "default": "published"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```