# Sams Club Reviews Scraper (Cheap) (`data_api/sams-club-reviews-scraper-cheap`) Actor

Sam's Club reviews scraper that collects product ratings and review text from samsclub.com, so e-commerce analysts and brand managers can monitor shopper sentiment without manual work.

- **URL**: https://apify.com/data\_api/sams-club-reviews-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

## Sam's Club Customer Reviews Scraper

![Sam's Club Customer Reviews Scraper](cover.jpg)

Reading Sam's Club reviews by hand stops working the moment you care about more than one item. The ratings live behind pagination, the star counts sit in a summary block, and copy-pasting hundreds of comments into a sheet is its own afternoon. Paste a review page URL here and the scraper walks every page for you, returning each review as a clean row: the star score, the headline, the full text, who wrote it, whether they actually bought the item, and how many shoppers found it helpful. Each row also carries the item's average score and total review count, so you have the headline numbers and the raw feedback side by side. Run one URL or a whole list.

### What you get

Each review comes back as one row with a steady set of columns, so loading results into a spreadsheet or database stays predictable. Two layers of data per row:

- **The review** — `feedbackId`, `starScore`, `headline`, `reviewText`, `authorName`, `submittedOn`, `verifiedBuyer`, `helpfulCount`, `feedbackTotal`
- **The item context** — `itemSku`, `reviewsPageUrl`, `averageScore`, `reviewsCount`, `scoreBreakdown`, plus `collectedAt` and `errorMessage`

### Quick start

1. Click **Try for free** and open the input form.
2. Paste one or more Sam's Club review page URLs into **Review page URLs**, one per line.
3. Set **Reviews to pull per item** to cap how many reviews you gather from each link.
4. Press **Start**, then export as JSON, CSV, Excel, or XML once the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Product research** — read what real buyers say before sourcing or reselling an item
- **Sentiment tracking** — group reviews by star score to see where a product wins or loses
- **Competitor comparison** — line up review counts and average scores across rival items
- **Quality monitoring** — watch for a drop in ratings or a spike in low-star complaints
- **Voice-of-customer mining** — pull review text in bulk to feed keyword or theme analysis
- **Catalog enrichment** — attach live rating data to your own product listings

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `reviewPageUrls` | array of strings | Yes | Sam's Club review page URLs to gather, one per line. Each link is handled on its own. |
| `reviewsLimit` | integer | No | How many reviews to pull from each URL. Default `50`. |
| `timeoutSeconds` | integer | No | Seconds allowed per request before it is dropped. Default `90`; raise it when deeper pages time out. |

#### Example input

```json
{
    "reviewPageUrls": [
        "https://www.samsclub.com/reviews/product/prod25430011?entryPoint=viewAllReviewsTop",
        "https://www.samsclub.com/reviews/product/990312885"
    ],
    "reviewsLimit": 50,
    "timeoutSeconds": 90
}
````

### Output

Every review becomes one row, and each row repeats the item-level numbers so a single record stands on its own. Fields with no value come back as `null` so the dataset stays rectangular.

#### Example output

```json
{
    "itemSku": "prod25430011",
    "reviewsPageUrl": "https://www.samsclub.com/reviews/product/prod25430011",
    "feedbackId": "rev_88421007",
    "starScore": 5,
    "headline": "Great value for a big family",
    "reviewText": "Bought this for our weekly grocery run and it has held up far better than the brand we used before. Will buy again.",
    "authorName": "Marisol G.",
    "submittedOn": "2026-05-18T14:22:00.000Z",
    "verifiedBuyer": true,
    "helpfulCount": 27,
    "feedbackTotal": 31,
    "averageScore": 4.6,
    "reviewsCount": 898,
    "scoreBreakdown": {
        "5": 612,
        "4": 143,
        "3": 71,
        "2": 34,
        "1": 38
    },
    "collectedAt": "2026-06-30T12:00:00.000000+00:00",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `itemSku` | string | Sam's Club item code pulled from the page link |
| `reviewsPageUrl` | string | Complete link to the Sam's Club reviews page |
| `feedbackId` | string | Identifier unique to this single review |
| `starScore` | number | Stars the shopper awarded, from 1 through 5 |
| `headline` | string | Short title the shopper gave the review |
| `reviewText` | string | Body copy of the review |
| `authorName` | string | Public nickname of the reviewer |
| `submittedOn` | string | When the review was posted |
| `verifiedBuyer` | boolean | True when the reviewer is a confirmed buyer |
| `helpfulCount` | integer | How many shoppers tagged the review as helpful |
| `feedbackTotal` | integer | Up- and down-votes combined |
| `averageScore` | number | Mean star rating for the item across all reviews |
| `reviewsCount` | integer | Total number of reviews the item has |
| `scoreBreakdown` | object | Reviews tallied by star level |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason the request failed; `null` on success |

### Tips for best results

- **Start with a couple of URLs.** Run two or three links before a large batch so any URL-format issue shows up early.
- **Set `reviewsLimit` to match your need.** Pulling 50 reviews per item is plenty for a quick read; raise it when you want the full history.
- **Raise `timeoutSeconds` for popular items.** Items with thousands of reviews page deeper, so 90-120 seconds keeps later pages from dropping.
- **Partial data still lands.** If a later page fails, the reviews already gathered are kept and the run moves on rather than losing everything.
- **Use the item-level numbers for a fast read.** `averageScore`, `reviewsCount`, and `scoreBreakdown` give you the summary picture without reading every comment.

### How can I use Sam's Club review data?

**How can I use the Sam's Club Customer Reviews Scraper to research a product before buying or reselling?**
Paste the item's review page URL and the scraper returns every review with its star score, full text, and verified-buyer flag, plus the item's average score and total review count. Sort by `starScore` to read the harshest and happiest takes first, then use `scoreBreakdown` to see how the ratings actually split.

**How can I export Sam's Club reviews to CSV or Excel for analysis?**
Run the scraper, let it gather the reviews, then export the dataset as CSV, Excel, JSON, or XML straight from the run page. Each review is one row with consistent columns, so it drops cleanly into a pivot table or a sentiment model without any reshaping.

**How can I track Sam's Club ratings across several products at once?**
Add a separate line for each item's review page URL under `reviewPageUrls` and the scraper handles them in one run. Because every row repeats `itemSku`, `averageScore`, and `reviewsCount`, you can group by item to compare ratings side by side and watch how feedback shifts over time.

**How can I pull review text in bulk for keyword or theme analysis?**
Set `reviewsLimit` high enough to capture the volume you want, then collect the `reviewText` and `headline` fields across all your items. The result is a tidy corpus of real shopper language you can feed into keyword counts, topic clustering, or any voice-of-customer workflow.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `reviewPageUrls` (type: `array`):

One or more Sam's Club review page links to gather in a single run. Add a separate line for each URL.

## `reviewsLimit` (type: `integer`):

How many reviews to gather for each URL. Every link is handled on its own up to this ceiling.

## `timeoutSeconds` (type: `integer`):

Seconds allowed for each request before it is dropped. Bump this to 90-120 when deeper pages start timing out.

## Actor input object example

```json
{
  "reviewPageUrls": [
    "https://www.samsclub.com/reviews/product/prod25430011?entryPoint=viewAllReviewsTop",
    "https://www.samsclub.com/reviews/product/990312885"
  ],
  "reviewsLimit": 10,
  "timeoutSeconds": 90
}
```

# 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 = {
    "reviewPageUrls": [
        "https://www.samsclub.com/reviews/product/15389952544?entryPoint=viewAllReviewsTop"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/sams-club-reviews-scraper-cheap").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 = { "reviewPageUrls": ["https://www.samsclub.com/reviews/product/15389952544?entryPoint=viewAllReviewsTop"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/sams-club-reviews-scraper-cheap").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 '{
  "reviewPageUrls": [
    "https://www.samsclub.com/reviews/product/15389952544?entryPoint=viewAllReviewsTop"
  ]
}' |
apify call data_api/sams-club-reviews-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sams Club Reviews Scraper (Cheap)",
        "description": "Sam's Club reviews scraper that collects product ratings and review text from samsclub.com, so e-commerce analysts and brand managers can monitor shopper sentiment without manual work.",
        "version": "0.0",
        "x-build-id": "Uh05PJyTdgtP0eDiN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~sams-club-reviews-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-sams-club-reviews-scraper-cheap",
                "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/data_api~sams-club-reviews-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-sams-club-reviews-scraper-cheap",
                "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/data_api~sams-club-reviews-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-sams-club-reviews-scraper-cheap",
                "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",
                "required": [
                    "reviewPageUrls"
                ],
                "properties": {
                    "reviewPageUrls": {
                        "title": "Review page URLs",
                        "type": "array",
                        "description": "One or more Sam's Club review page links to gather in a single run. Add a separate line for each URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reviewsLimit": {
                        "title": "Reviews to pull per item",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many reviews to gather for each URL. Every link is handled on its own up to this ceiling.",
                        "default": 10
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Seconds allowed for each request before it is dropped. Bump this to 90-120 when deeper pages start timing out.",
                        "default": 90
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
