# Judge.me Reviews Scraper 💰 $1/1K | Shopify Product Reviews (`ahmed_jasarevic/judge-me-scraper`) Actor

Scrape product and store reviews from any Judge.me-powered Shopify store. Get rating, title, body, reviewer, date, photos, verified-buyer flag and merchant reply for sentiment analysis and competitor benchmarking.

- **URL**: https://apify.com/ahmed_jasarevic/judge-me-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Judge.me Reviews Scraper — Shopify Product & Store Reviews

Scrape **product and store reviews from any Judge.me-powered storefront** (Shopify, WooCommerce, BigCommerce) — the whole store or a single product — straight from Judge.me's own public review widget API. Get rating, title, body, reviewer, date, photos, verified-buyer flag and merchant reply.

### Main Use Cases

- **E-commerce review monitoring** — track your own and competitors' review sentiment and volume over time.
- **Competitor benchmarking** — compare ratings, review counts and verified-buyer share against rival stores.
- **Sentiment analysis** — export review text and ratings for NLP and product-feedback pipelines.
- **Agency audits** — audit client storefronts' review health across Shopify, WooCommerce and BigCommerce.
- **Review dataset building** — assemble a structured review dataset at scale for market research.

### How It Works

![How the Judge.me Scraper works: any storefront to every customer review with rating, photos and merchant replies.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-judge-me.webp)

Judge.me renders its storefront review widget from a set of **public, unauthenticated JSON endpoints**. This actor talks to those endpoints directly — no browser, no Playwright, no login, no private credentials. It first resolves the Judge.me shop identity for any store URL, then pages through the public review feed using `json_request=true`, which returns structured JSON instead of HTML.

Point it at a store homepage or a single product URL, choose the feed order, and every review comes back as one flat row with rating, photos and merchant replies.

### Scrape Judge.me Reviews From Any Shopify Store

Give the actor a store homepage, a bare domain or a `*.myshopify.com` host and it returns that store's whole review feed. Give it a `/products/{handle}` URL and it returns only that product's reviews. Every row is a flat record you can drop straight into a spreadsheet or analysis pipeline.

### Extract E-Commerce Review Data Without An Official API

Judge.me exposes no product-facing API for exporting reviews. This actor reads the same public widget data a visitor's browser loads and returns clean JSON, so you can build a review dataset or run sentiment analysis without an API key or Shopify access.

### Input

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `startUrls` | array | yes | — | Store homepage / any store page / bare domain (whole-store feed) **or** a `/products/{handle}` URL (single product). `*.myshopify.com` hosts work too. |
| `maxItems` | integer | no | `100` | Max reviews across all targets. Judge.me caps a store's public feed at 10,000 reviews. |
| `includeShopReviews` | boolean | no | `false` | Also scrape store-level reviews (store targets only). |
| `sortBy` | select | no | `newest` | `newest`, `highest_rating` or `lowest_rating`. |
| `maxConcurrency` | integer | no | `5` | Parallel requests (1–20). |
| `proxy` | object | no | `{ "useApifyProxy": false }` | Standard Apify proxy configuration. Off by default. |

### Output

One dataset item per review (`type: "review"`). Views: **overview** (rating, title, body, reviewer, date, verified, product, shop) and **details** (every field).

| Field | Type | Description |
| --- | --- | --- |
| `type` | string | Always `review` |
| `reviewId` | string | Judge.me review UUID |
| `rating` | integer | Star rating (1–5) |
| `title` | string | Review headline |
| `body` / `bodyHtml` | string | Plain-text and HTML review body |
| `reviewerName` / `reviewerInitial` | string | Reviewer name and avatar initial |
| `verifiedBuyer` | boolean | Whether the review is a verified purchase |
| `reviewDate` | string (date-time) | When the review was written |
| `photos` / `videos` | array | Attached photo URLs and video ids |
| `merchantReply` | string | Merchant's reply to the review |
| `thumbsUp` / `thumbsDown` | integer | Helpful / unhelpful votes |
| `location` / `locationCountry` | string | Reviewer's city/region and country |
| `source` | string | Where the review came from (e.g. shop-app, email) |
| `isShopReview` | boolean | True for store-level rather than product reviews |
| `productTitle` / `productUrl` / `productHandle` / `productExternalId` | string | Reviewed product identity |
| `shopDomain` / `shopName` / `shopSlug` / `storeUrl` / `platform` | string | Store identity (shopify, woocommerce, …) |
| `scrapedAt` | string (date-time) | When the review was scraped |

### Example Input

Whole store:

```json
{ "startUrls": [{ "url": "https://www.uklash.com" }], "maxItems": 200 }
```

Single product:

```json
{ "startUrls": [{ "url": "https://www.uklash.com/products/lash-growth-serum" }], "maxItems": 100 }
```

### Example Output

```json
{
  "type": "review",
  "reviewId": "992b5b69-b346-4982-a177-5d8e3544b974",
  "rating": 5,
  "title": "Pestanas mas largas, si!",
  "body": "Efectivamente las pestanas crecen...",
  "reviewerName": "sofia v.",
  "verifiedBuyer": true,
  "reviewDate": "2023-02-27T08:04:38.792Z",
  "photos": ["https://review-images.judgeme.com/.../original.jpg"],
  "videos": [],
  "merchantReply": null,
  "thumbsUp": 4,
  "thumbsDown": 0,
  "isShopReview": false,
  "productTitle": "Sérum De Pestañas",
  "productHandle": "serum-para-pestanas",
  "productExternalId": "1466952777817",
  "shopDomain": "uklash1.myshopify.com",
  "shopName": "UKLASH",
  "shopSlug": "www.uklash.com",
  "storeUrl": "https://www.uklash.com",
  "platform": "shopify",
  "scrapedAt": "2026-10-15T09:00:00.000Z"
}
```

### Integrations & Automation

- **Apify API** — trigger runs and read the dataset programmatically.
- **Webhooks** — act on new reviews (e.g. alert on a 1-star review).
- **Zapier / Make** — pipe reviews into Google Sheets, Airtable or a sentiment tool.

**Recommended schedule:** run **daily** for reputation monitoring and 1-star alerting; **weekly** for competitor benchmarking and review-volume trend reports.

### Related Actors

- [Shopify Product Scraper](https://apify.com/ahmed_jasarevic/shopify-product-scraper) — catalog, inventory and product data from Shopify stores.
- [Shopify Scraper](https://apify.com/ahmed_jasarevic/shopify-scraper) — tech stack, apps and themes of Shopify stores.
- [Trustpilot Scraper](https://apify.com/ahmed_jasarevic/trustpilot-reviews-scraper) — Trustpilot reviews, ratings and sentiment.
- [Yelp Scraper](https://apify.com/ahmed_jasarevic/yelp-scraper) — Yelp reviews, ratings and business data.
- [Glassdoor Scraper](https://apify.com/ahmed_jasarevic/glassdoor-scraper) — reviews, jobs, salaries and interviews.

### FAQ

#### Why use this actor instead of the official API?

Judge.me has no product-facing API for exporting a store's reviews in bulk. This actor reads the same **public, unauthenticated** widget data a visitor's browser loads and returns it as structured JSON, with no API key and no private credentials.

#### What are alternatives to this actor or to review data?

Trustpilot and Yelp cover public reviews on those platforms, and this actor's own Trustpilot and Yelp scrapers cover them. Within Shopify/Judge.me storefronts, this actor is the bulk product-and-store review scraper.

#### Is the data public or does it need a login?

Public only. The actor uses the shop's **public** widget token — the same value every storefront's review widget exposes in a visitor's browser. It does not use private API tokens, authenticated endpoints, or anything behind a login.

#### Can I scrape Judge.me store-level reviews as well as product reviews?

Yes. Enable `includeShopReviews` on a store target to also scrape reviews written about the store rather than a specific product.

#### What is the review limit?

Judge.me caps a store's public review feed at **10,000** reviews; `maxItems` is capped accordingly.

#### How do I export Judge.me reviews to CSV or Excel?

Every run writes to an Apify dataset; use the console **Export** button or the dataset API endpoint to download CSV, Excel or JSON.

### For AI Agents & LLM Apps

Purpose: return product and store reviews from any Judge.me-powered storefront as flat JSON records with rating, text, reviewer, date, photos, verified-buyer flag and product/store identifiers.

Minimal working input:

```json
{ "startUrls": [{ "url": "https://examplestore.com" }] }
```

Variant inputs:

```json
{ "startUrls": [{ "url": "https://examplestore.com/products/handle" }], "maxItems": 100, "sortBy": "lowest_rating" }
```

```json
{ "startUrls": [{ "url": "examplestore.com" }], "includeShopReviews": true, "maxItems": 500 }
```

Output fields (dataset): `type, reviewId, rating, title, body, bodyHtml, reviewerName, reviewerInitial, verifiedBuyer, reviewDate, photos, videos, merchantReply, thumbsUp, thumbsDown, location, locationCountry, source, isShopReview, productTitle, productUrl, productHandle, productExternalId, shopDomain, shopName, shopSlug, storeUrl, platform, scrapedAt`.

Behaviors an agent should know:

- `startUrls` is the **only required** field; the actor resolves the Judge.me shop identity automatically from a store URL, bare domain or `*.myshopify.com` host.
- A store URL (homepage/domain) scrapes the **whole store**; a `/products/{handle}` URL scrapes only that product's reviews.
- Stores **without** Judge.me installed are reported in the log and skipped, never silently returned as zero rows.
- `sortBy` controls the order Judge.me returns reviews in; `includeShopReviews` only applies to store targets.
- Billing model: pay-per-event — one `apify-default-dataset-item` charge per review (~$0.001/result at the entry tier, i.e. ~$1 per 1,000 reviews) plus one `apify-actor-start` charge per run.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Judge.me**. It reads only the same publicly available, unauthenticated review-widget data a normal visitor's browser loads; it does not use private API tokens, authenticated endpoints, or anything behind a login, and it does not bypass CAPTCHAs. Users are responsible for their own compliance with Judge.me's and the target store's Terms of Service and applicable data-protection law (including, where relevant, GDPR/CCPA for reviewer personal data such as names and locations).

### SEO Keywords

judge.me scraper, judgeme reviews, judgeme api, shopify reviews scraper, product reviews scraper, store reviews scraper, ecommerce review data, review monitoring, competitor review analysis, sentiment analysis data, verified buyer reviews, shopify review data, woo reviews scraper, bigcommerce reviews, review dataset, competitor benchmarking reviews, product review api alternative, ecommerce review monitoring, dtc brand reviews, judgeme export csv, judgeme review scraper, shopify product reviews data

# Actor input Schema

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

Judge.me-powered storefronts to scrape. Paste a store homepage / any store page / bare domain (e.g. https://www.uklash.com or uklash.com) to get the store's whole review feed, or a product URL (e.g. https://www.uklash.com/products/lash-growth-serum) to get only that product's reviews. A \*.myshopify.com host also works.

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

Maximum number of reviews to scrape across all targets. Judge.me caps a store's public review feed at 10,000 reviews.

## `includeShopReviews` (type: `boolean`):

Also scrape the store's shop-level reviews (reviews written about the store rather than a specific product). Only applies to store targets.

## `sortBy` (type: `string`):

Order in which reviews are returned by Judge.me.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.uklash.com"
    }
  ],
  "maxItems": 100,
  "includeShopReviews": false,
  "sortBy": "newest",
  "maxConcurrency": 5,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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.uklash.com"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/judge-me-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.uklash.com" }],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/judge-me-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.uklash.com"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/judge-me-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/judge-me-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/S6n88T0USFliWMQX7/builds/LMGTNkd5tqGZXrYUz/openapi.json