# Reviews.io Reviews Scraper (`automation-lab/reviews-io-scraper`) Actor

Extract public Reviews.io company reviews, ratings, reviewer names, dates, replies, and aggregate reputation metrics for monitoring.

- **URL**: https://apify.com/automation-lab/reviews-io-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** SEO tools
- **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

## Reviews.io Reviews Scraper

Extract public customer reviews from Reviews.io company pages into a clean Apify dataset.

Reviews.io is used by ecommerce brands, travel companies, agencies, and service businesses to collect public customer feedback. This actor turns those public review pages into structured data you can export to CSV, JSON, Excel, Google Sheets, BI tools, or your own data warehouse.

### What does Reviews.io Reviews Scraper do?

Reviews.io Reviews Scraper collects review records from public Reviews.io company review pages.

It reads pages such as:

- `https://www.reviews.io/company-reviews/store/loveholidays-com`
- Any other public Reviews.io `/company-reviews/store/...` page
- Plain store keys such as `loveholidays-com`

For each review, it saves the rating, reviewer name, date, review text, source URL, company-level rating, and other traceability fields.

### Who is it for?

This actor is useful for teams that need repeatable review monitoring.

- 🛍️ Ecommerce operators tracking customer sentiment
- 📈 SEO teams building reputation reports
- 🧑‍💼 Agencies monitoring many client brands
- 🧪 Product teams analyzing review themes
- 🧾 Compliance teams archiving public feedback
- 🏨 Travel and hospitality analysts comparing public ratings
- 🤖 AI teams feeding review text into summarization or classification workflows

### Why use this actor?

Manual review collection is slow and error-prone. Reviews.io pages are readable in a browser, but exports are not always available for competitive research, public reputation monitoring, or multi-brand reporting.

This actor gives you:

- Structured rows instead of copied text
- Repeatable runs for daily or weekly monitoring
- A simple input format: URLs or store keys
- Low-cost HTTP scraping without a browser
- Dataset output that works with Apify integrations

### What data can you extract?

| Field | Description |
| --- | --- |
| `storeKey` | Reviews.io store slug from the URL |
| `companyName` | Company or store name from page metadata |
| `companyUrl` | Company website URL when exposed |
| `sourceUrl` | First Reviews.io page requested for the store |
| `pageUrl` | Exact page URL where the review was found |
| `pageNumber` | Pagination counter used by the actor |
| `aggregateRating` | Company-level average rating |
| `totalReviewCount` | Company-level public review count |
| `reviewerName` | Reviewer display name |
| `reviewDate` | Review publication date |
| `rating` | Review star rating |
| `reviewTitle` | Review title or headline when present |
| `reviewText` | Review body text |
| `verified` | Verification signal when visible near the review |
| `companyReplyText` | Public company response text when detected |
| `companyReplyDate` | Public company response date when detected |
| `scrapedAt` | Actor run timestamp |

### How much does it cost to scrape Reviews.io reviews?

The actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A review event is charged for each saved review.
- You control spend with `maxReviews` and `maxPagesPerCompany`.

Typical first tests should use 10-25 reviews. Larger recurring monitoring runs can increase the limit after you confirm the target pages contain the data you need.

### How to use Reviews.io Reviews Scraper

1. Open the actor on Apify.
2. Paste one or more Reviews.io company review URLs.
3. Set `maxReviews` to the number of reviews you want.
4. Optionally set `maxPagesPerCompany` to limit pagination.
5. Run the actor.
6. Download results from the dataset tab.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.reviews.io/company-reviews/store/loveholidays-com" }
  ],
  "maxReviews": 25,
  "maxPagesPerCompany": 3
}
````

### Input fields

#### `startUrls`

Paste full Reviews.io company review URLs. This is the recommended input for most users.

#### `storeKeys`

Optional list of plain store keys. Use this when you already know the Reviews.io slug and do not want to paste full URLs.

#### `maxReviews`

Total number of review records to save across all companies in the run.

#### `maxPagesPerCompany`

Pagination safety limit for each company page. Increase it when you need more historical reviews.

### Output example

```json
{
  "storeKey": "loveholidays-com",
  "companyName": "loveholidays.com",
  "companyUrl": "https://www.loveholidays.com/",
  "sourceUrl": "https://www.reviews.io/company-reviews/store/loveholidays-com",
  "pageUrl": "https://www.reviews.io/company-reviews/store/loveholidays-com",
  "pageNumber": 1,
  "aggregateRating": 3.04,
  "totalReviewCount": 5081,
  "reviewerName": "Anonymous",
  "reviewDate": "2026-05-26 07:34:13",
  "rating": 5,
  "reviewTitle": null,
  "reviewText": "Everything went well...",
  "verified": true,
  "companyReplyText": null,
  "companyReplyDate": null,
  "scrapedAt": "2026-05-26T09:00:00.000Z"
}
```

### Tips for best results

- Start with a low `maxReviews` value to validate the target store.
- Use full Reviews.io URLs when possible.
- Run on a schedule to monitor new reviews over time.
- Keep the `pageUrl` field when deduplicating historical exports.
- Combine `storeKey` and `reviewDate` with review text for deduplication.

### Common use cases

- Daily review monitoring for your own brand
- Competitive reputation reports
- Negative-review alerting workflows
- Customer sentiment analysis
- Support quality audits
- Product feedback clustering
- Public review archiving

### Integrations

Apify datasets can be connected to many downstream systems.

- Google Sheets for stakeholder reports
- Slack or email alerts for low ratings
- BigQuery or Snowflake for analytics
- Make and Zapier automations
- Webhooks for review monitoring pipelines
- LLM summarization for weekly sentiment briefs

### 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/reviews-io-scraper').call({
  startUrls: [{ url: 'https://www.reviews.io/company-reviews/store/loveholidays-com' }],
  maxReviews: 25,
  maxPagesPerCompany: 3,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/reviews-io-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.reviews.io/company-reviews/store/loveholidays-com'}],
    'maxReviews': 25,
    'maxPagesPerCompany': 3,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~reviews-io-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.reviews.io/company-reviews/store/loveholidays-com"}],"maxReviews":25,"maxPagesPerCompany":3}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP Server.

MCP URL:

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

Claude Code setup:

```bash
claude mcp add apify-reviews-io https://mcp.apify.com/?tools=automation-lab/reviews-io-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Scrape the latest 25 Reviews.io reviews for this company URL."
- "Run the Reviews.io scraper and summarize the top complaints."
- "Compare average rating and recent review text for these two store keys."

### Scheduling

You can schedule the actor in Apify Console.

Suggested schedules:

- Daily for active reputation monitoring
- Weekly for agency reporting
- Monthly for competitor snapshots

### Data quality notes

The actor extracts public information exposed in the page HTML and JSON-LD. Some optional fields, such as company replies or verification badges, may not appear on every page or every review.

If a target page has no public reviews, the actor may finish with fewer rows than requested.

### FAQ

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

The store may have fewer public reviews available in the fetched pages, or `maxPagesPerCompany` may be too low. Increase the page limit and run again.

#### Why is `companyReplyText` empty?

Not every review has a public company reply. The field is populated only when a response is visible and detected near the review.

#### Why does my URL fail?

Make sure the URL is a public Reviews.io company review page containing `/company-reviews/store/`.

### Legality and ethical use

This actor is designed for public web data. Always use the data responsibly, respect applicable laws, and follow the terms that apply to your use case. Do not use scraped data for spam, harassment, or unlawful profiling.

### Related scrapers

You may also be interested in other automation-lab reputation and review actors:

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

### Limitations

- The actor does not log in to private Reviews.io dashboards.
- It does not bypass access controls.
- It extracts what is publicly visible in the page response.
- Optional fields depend on what Reviews.io exposes for each store.

### Version notes

Version 0.1 focuses on public company review pages, JSON-LD review extraction, pagination, and clean dataset output.

### Support

If a public Reviews.io company page does not work as expected, share the run ID and input with support so the extractor can be checked against the current page structure.

# Actor input Schema

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

Paste Reviews.io company review page URLs, for example https://www.reviews.io/company-reviews/store/loveholidays-com.

## `storeKeys` (type: `array`):

Optional plain Reviews.io store keys such as loveholidays-com. Use this if you do not have full URLs.

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

Maximum number of review records to save across all companies.

## `maxPagesPerCompany` (type: `integer`):

Safety limit for pagination on each Reviews.io company page.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reviews.io/company-reviews/store/loveholidays-com"
    }
  ],
  "storeKeys": [],
  "maxReviews": 20,
  "maxPagesPerCompany": 3
}
```

# Actor output Schema

## `reviews` (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.reviews.io/company-reviews/store/loveholidays-com"
        }
    ],
    "storeKeys": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/reviews-io-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.reviews.io/company-reviews/store/loveholidays-com" }],
    "storeKeys": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/reviews-io-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.reviews.io/company-reviews/store/loveholidays-com"
    }
  ],
  "storeKeys": []
}' |
apify call automation-lab/reviews-io-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reviews.io Reviews Scraper",
        "description": "Extract public Reviews.io company reviews, ratings, reviewer names, dates, replies, and aggregate reputation metrics for monitoring.",
        "version": "0.1",
        "x-build-id": "9zdt8TFUuOSDjsmCQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~reviews-io-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-reviews-io-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~reviews-io-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-reviews-io-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~reviews-io-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-reviews-io-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": "Reviews.io company URLs",
                        "type": "array",
                        "description": "Paste Reviews.io company review page URLs, for example https://www.reviews.io/company-reviews/store/loveholidays-com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "storeKeys": {
                        "title": "Store keys",
                        "type": "array",
                        "description": "Optional plain Reviews.io store keys such as loveholidays-com. Use this if you do not have full URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of review records to save across all companies.",
                        "default": 20
                    },
                    "maxPagesPerCompany": {
                        "title": "Maximum pages per company",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety limit for pagination on each Reviews.io company page.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
