# Shopify Judge.me Reviews Scraper API (`lurkapi/shopify-judge-me-reviews-scraper-api`) Actor

Scrape Judge.me reviews from Shopify product URLs or scan store sitemaps for product ratings and review counts.

- **URL**: https://apify.com/lurkapi/shopify-judge-me-reviews-scraper-api.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** AI, Automation, E-commerce
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 reviews

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Shopify Judge.me Reviews Scraper API

Pull every public Judge.me review from any Shopify store into one clean spreadsheet. Every 1-star from a competitor's launch quarter, a catalog-wide rating sweep of your own storefront, or the full review history for a single SKU. Ready to filter, sort, and download in minutes.

### 🎬 What it does

Paste a Shopify store URL, product URL, or landing page with an embedded Judge.me product widget. Get back reviews in a spreadsheet.

Two kinds of input:

1. **Store URL** returns one summary row per public product on the store, including the SKUs sitting at zero reviews. Good for catalog-wide dashboards, launch-week rating sweeps, and finding the quiet products in your own store.
2. **Product URL or product landing page** returns every individual review on the exact embedded product. Good for quote pulls, monthly agency reports, and single-SKU deep dives.

Shape the results before you pay for them:

- **Free filters and sorts**: keep any mix of 1 to 5 stars, search review text, keep verified buyers or reviews with media, and sort by most recent, highest rating, lowest rating, most helpful, pictures first, or videos first.
- **Paid photo, video, and reply filters**: photos only, videos only, or reviews the store has publicly replied to.
- **Paid date and language filters**: narrow to a specific date window, or the set of languages you actually read.
- **Paid text or ratings-only**: keep only reviews with written text, or only star ratings without text.
- **Paid custom sort**: reverse the newest-first order to oldest-first.
- **Paid enrichments**: tag each review with a detected language, translate reviews into your chosen language when Judge.me has not already translated them, and archive photo and video files to your run storage.

Equivalent versions of the same URL collapse automatically. A store and one of its products remain separate targets because they return different row types. Locale-prefixed product URLs and the `www.` prefix are normalized. Status rows are always free.

Good for: Shopify founders watching their own reviews week over week, CMOs auditing a competitor's launch quarter, agencies scoring a client roster monthly, and analysts building review datasets they can actually trust.

### 📋 How to use it

#### Step 1: Paste your inputs

Drop any combination into **Start URLs**, one per line. Equivalent URL variants are cleaned up automatically.

- **Store URL**: `https://bravelittleones.com/`
- **Product URL**: `https://bravelittleones.com/products/cookies-and-milk-zip-romper`
- **Landing page**: any non-product page that embeds a Judge.me product review widget. The Actor resolves its embedded Shopify product ID before collecting reviews.

Minimum input, run as-is:

```json
{
  "startUrls": [
    "https://bravelittleones.com/",
    "https://bravelittleones.com/products/cookies-and-milk-zip-romper"
  ],
  "maxResultsPerUrl": 50
}
```

`maxResultsPerUrl` is the only limit you need. Default 50, max 50,000. For a store URL it caps product summaries. For a product URL it caps reviews.

#### Step 2: Pick filters and add-ons

Free filters and sorts supported by Judge.me:

- **Star rating filter**: keep any combination of 1 to 5 stars.
- **Keyword search**: only reviews whose title or body contains your phrase.
- **Verified only**: only reviews Judge.me marks as verified.
- **Any media**: only reviews with a photo or video.
- **Sort order**: Most recent, Highest rating, Lowest rating, Most helpful, Pictures first, or Videos first.

Paid add-ons (billed only when they actually deliver a row):

- **Specific media filters**: only reviews with a photo or only reviews with a video.
- **Store-reply only**: only reviews the merchant has publicly replied to.
- **Date range**: only reviews posted between two dates.
- **Written vs rating-only**: keep only reviews with text, or only star-ratings without text.
- **Language filter**: only reviews in the languages you pick.
- **Oldest-first sort**: reverse the newest-first order.
- **Language detection**: adds a language tag on every review, billed only when detection succeeds.
- **Translation**: translates reviews into your chosen language, billed only when a translation is returned. When Judge.me already provides its own translation for a review, that one is used for free. Same-language reviews are skipped so you are not billed for no-op translations.
- **Media archiving**: downloads and stores up to 10 photos or videos per review (3 MB per file cap), billed only per file stored.

#### Step 3: Run it and get your results

Click **Start**. Rows stream into the Output tab as they come in. The dataset ships with four ready-made views:

- **Overview**: high-level shape of every row.
- **Products**: one row per catalog product from a store scan.
- **Reviews**: one row per review from a product scan.
- **Language & Media**: detected languages, translated text, and archived media.

Every row starts with a `status` field. `Success` means the row is real data. Explanatory rows contain a plain-language status plus a stable `error` code such as `no_products_found` or `judge_me_not_detected`. These rows are never charged.

Download as JSON, CSV, or Excel from the Storage tab, or pull them straight into your app through the Apify API.

### 💰 Pricing

Pay only for results you actually get back. No subscription, no minimum.

| Event | Price | When |
|---|---|---|
| Result delivered | **$1.50 per 1,000 rows** | per product summary or review delivered |
| Add-on: Advanced filter | **$0.50 per 1,000 rows** | per delivered review kept by a post-fetch photo, video, reply, date, content, or language filter |
| Add-on: Custom sort | **$0.50 per 1,000 rows** | per delivered review from an oldest-first sort |
| Add-on: Language detected | **$0.50 per 1,000 rows** | per delivered review where the Actor detected the language |
| Add-on: Review translated | **$2.00 per 1,000 rows** | per delivered review that was actually translated |
| Add-on: Media downloaded | **$1.00 per 1,000 files** | per media file archived successfully |

Rating filters, native Judge.me sorts, source photo and video URLs, Judge.me's own translations, and status rows are all free.

A base scan is $1.50 per 1,000 rows. A fully enhanced workflow with date filtering, language detection, translation, and media archiving can approach $5 per 1,000 rows depending on the options you turn on.

### 💡 Good to know

- **Exact-product only**. Judge.me lets merchants group products so a single review shows up on several product pages. The Actor keeps only the reviews that truly belong to the product URL you gave it. On a store scan the product-level rating summary still reflects whatever Judge.me shows on the storefront.
- **Zero-review products are included** on store scans. Your catalog view stays complete, with `reviewCount: 0` on the quiet SKUs.
- **Dedup is automatic**. The same store or product reached through several URL variants (locale prefix, `www.`, trailing slash, extra query strings, mixed case) is fetched once.
- **Not on Judge.me?** If the page exposes a supported sibling review widget, the uncharged `judge_me_not_detected` row names the provider and links directly to its matching Actor. Detection covers Air / AG Product Reviews, Junip, Loox, Okendo, TrustWILL, and Yotpo.
- **Status rows are never charged**. Unsupported providers, empty filtered results, and rejected URLs come back with a stable `error` value that explains the fix.
- **Field coverage matches the source**. If the storefront did not publish a value (for example, reviewer location on many stores), the field comes back `null`. Fields you toggle off in the 📦 Output fields section are omitted from the row entirely.
- **Media limits are strict**. Up to 10 files per review, 3 MB per file. Only real photo and video files are archived. HTML, SVG, and embedded video players (YouTube, Vimeo) are never downloaded, but their public URLs stay in `videoUrls`.
- **Runs are independent**. No cross-run history is kept. Schedule runs and compare `reviewId` on your side to track what is new.
- Files and datasets live in your Apify storage. How long they are kept depends on your Apify plan.

### ❓ FAQ

**Do I need a Judge.me or Shopify account?**
No. Only publicly published storefront and review data is read.

**What if a store does not use Judge.me?**
You get one uncharged status row that explains it. Try one of the sibling scrapers (Okendo, Loox, Yotpo) if the store uses a different review app.

**What if a product has no reviews?**
On a store scan you still get the product summary row with `reviewCount: 0` and empty rating fields. On a product scan pointing at a review-less product you get a status row that says no reviews matched.

**Why did I get fewer reviews than the store shows?**
Judge.me lets merchants show reviews from grouped or related products on a single product page. This Actor returns only the reviews that truly belong to the product URL you gave it, so the row count on a product scan can be lower than the number displayed on the storefront.

**Why are some fields null?**
Not every store publishes every field. `null` means the field was requested but the storefront did not expose it. Fields you toggle off are omitted entirely.

**Can I schedule this?**
Yes. Use Apify Schedules to run on any cadence and compare `reviewId` across snapshots to track new reviews.

**Can I export to Excel or Google Sheets?**
Yes. Open the run's Storage tab and pick CSV, Excel, JSON, or one of the other formats.

**Which stores work?**
Any Shopify store whose review widget is powered by Judge.me and whose public product catalog is reachable.

**How long are my results stored?**
Results live in your Apify dataset. How long they are kept depends on your Apify plan.

### 🔗 Other tools you might like

- [Shopify Okendo Reviews Scraper API](https://apify.com/lurkapi/shopify-okendo-reviews-scraper-api): same job for stores running Okendo.
- [Shopify Loox Reviews Scraper API](https://apify.com/lurkapi/shopify-loox-reviews-scraper-api): same job for stores running Loox.
- [Shopify Yotpo Reviews Scraper API](https://apify.com/lurkapi/shopify-yotpo-reviews-scraper-api): same job for stores running Yotpo.
- [Shopify Junip Reviews Scraper API](https://apify.com/lurkapi/shopify-junip-reviews-scraper-api): same job for stores running Junip.
- [Shopify Air / AG Product Reviews Scraper API](https://apify.com/lurkapi/shopify-air-ag-product-reviews-scraper-api): same job for stores running Air or AG Product Reviews.
- [Shopify TrustWILL Reviews Scraper API](https://apify.com/lurkapi/shopify-trustwill-reviews-scraper-api): same job for stores running TrustWILL or Trustoo.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with Shopify's and Judge.me's Terms of Service and any laws that apply in your jurisdiction. The developer is not liable for misuse. Data availability depends on the storefront's public configuration at run time.

**Keywords:** shopify reviews, judge.me reviews, shopify review scraper, judge.me review scraper, product reviews export, shopify product ratings, review dataset, review sentiment data, shopify catalog audit, ecommerce review data

# Actor input Schema

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

Paste a Shopify store URL to get one summary row per public product (including products with zero reviews). Paste a product URL, or a landing page that embeds a Judge.me product widget, to get reviews for that exact product. These inputs can be mixed in the same run.

## `maxResultsPerUrl` (type: `integer`):

Cap on rows returned for each input URL. A store URL returns up to this many product summaries; a product URL returns up to this many individual reviews.

## `filterRatings` (type: `array`):

Only keep reviews with the star ratings you pick. Leave empty to include every rating. Free with the base row price.

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

Judge.me's built-in orders (most recent, highest rating, lowest rating, most helpful, pictures first, videos first) are free. Oldest first counts as a custom-sort add-on.

## `filterKeyword` (type: `string`):

Only keep reviews whose title or body contains this phrase. This uses Judge.me's public widget filter and has no add-on charge.

## `verifiedOnly` (type: `boolean`):

Only keep reviews Judge.me marks as verified purchases. This uses Judge.me's public widget filter and has no add-on charge.

## `onlyWithMedia` (type: `boolean`):

Only keep reviews that include at least one photo or video. This uses Judge.me's public widget filter and has no add-on charge.

## `onlyWithPhotos` (type: `boolean`):

Only keep reviews that include at least one customer photo.

## `onlyWithVideos` (type: `boolean`):

Only keep reviews that include at least one customer video.

## `merchantReplyOnly` (type: `boolean`):

Only keep reviews the store has publicly replied to.

## `filterStartDate` (type: `string`):

Only keep reviews posted on or after this date (YYYY-MM-DD, inclusive).

## `filterEndDate` (type: `string`):

Only keep reviews posted on or before this date (YYYY-MM-DD, inclusive).

## `reviewContent` (type: `string`):

Keep every review, only reviews that have written text, or only star-ratings without text.

## `filterLanguages` (type: `array`):

Only keep reviews written in these languages. Use short codes like en, es, de, ja, or the 3-letter ISO 639-3 form such as eng, spa, deu, jpn.

## `detectLanguage` (type: `boolean`):

Add a detectedLanguage field on every review, worked out from the review text. Charged only when a language is detected successfully.

## `translateReviews` (type: `boolean`):

Translate the review title and body into your chosen target language. When Judge.me already provides its own translation for a review, that one is used for free. Same-language reviews (source equals target) are skipped so you are not billed for no-op translations.

## `translationTarget` (type: `string`):

Target language for translations. Use a short code such as en, es, fr, de, ja, or pt-BR.

## `downloadMedia` (type: `boolean`):

Save up to 10 verified photos or direct video files per review (3 MB per file cap) to the run's key-value store. Original source URLs stay in the row either way. Charged per file successfully stored. Embedded YouTube and Vimeo players are not downloadable, so their public URLs stay in videoUrls without a charge.

## `outputStoreDomain` (type: `boolean`):

Normalized store host, for example bravelittleones.com.

## `outputStoreUrl` (type: `boolean`):

Full canonical URL of the store's home page.

## `outputProductHandle` (type: `boolean`):

The URL slug Shopify uses in product paths.

## `outputProductTitle` (type: `boolean`):

Public product name.

## `outputProductUrl` (type: `boolean`):

Canonical link to the product page.

## `outputProductImageUrl` (type: `boolean`):

URL of the primary product image.

## `outputProductDescription` (type: `boolean`):

Plain-text product description (product-summary rows only).

## `outputPrice` (type: `boolean`):

Public price shown on the storefront.

## `outputCurrency` (type: `boolean`):

Storefront currency code, when it can be detected.

## `outputAvailable` (type: `boolean`):

Whether the product is publicly for sale.

## `outputAverageRating` (type: `boolean`):

Judge.me's product-level average rating.

## `outputReviewCount` (type: `boolean`):

Total number of Judge.me reviews on the product.

## `outputRatingHistogram` (type: `boolean`):

Review counts broken down by star rating.

## `outputJudgeMeDetected` (type: `boolean`):

Whether the Actor confirmed the product uses the Judge.me widget.

## `outputReviewerName` (type: `boolean`):

Public display name Judge.me shows for the reviewer.

## `outputPublishedAt` (type: `boolean`):

Timestamp when the review was posted.

## `outputVerifiedBuyer` (type: `boolean`):

Judge.me's verified-purchase flag on each review.

## `outputReply` (type: `boolean`):

Public reply the store posted to the review, as plain text.

## `outputMediaUrls` (type: `boolean`):

Source URLs for customer photos and videos on each review.

## `outputJudgeMeDetails` (type: `boolean`):

Extras from Judge.me: anonymous flag, reviewer location and country code, review source, helpful and not-helpful vote counts, and custom question answers.

## `outputInputUrl` (type: `boolean`):

The URL from your input that produced this row. Useful for grouping results.

## Actor input object example

```json
{
  "startUrls": [
    "https://bravelittleones.com/products/cookies-and-milk-zip-romper"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "most_recent",
  "verifiedOnly": false,
  "onlyWithMedia": false,
  "onlyWithPhotos": false,
  "onlyWithVideos": false,
  "merchantReplyOnly": false,
  "reviewContent": "all",
  "filterLanguages": [],
  "detectLanguage": false,
  "translateReviews": false,
  "translationTarget": "en",
  "downloadMedia": false,
  "outputStoreDomain": true,
  "outputStoreUrl": true,
  "outputProductHandle": true,
  "outputProductTitle": true,
  "outputProductUrl": true,
  "outputProductImageUrl": true,
  "outputProductDescription": true,
  "outputPrice": true,
  "outputCurrency": true,
  "outputAvailable": true,
  "outputAverageRating": true,
  "outputReviewCount": true,
  "outputRatingHistogram": true,
  "outputJudgeMeDetected": true,
  "outputReviewerName": true,
  "outputPublishedAt": true,
  "outputVerifiedBuyer": true,
  "outputReply": true,
  "outputMediaUrls": true,
  "outputJudgeMeDetails": true,
  "outputInputUrl": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Compact mixed view of all result rows.

## `products` (type: `string`):

One product rating row per public catalog product from store inputs.

## `reviews` (type: `string`):

One review row per exact-product review from product inputs.

## `enrichments` (type: `string`):

Language detection, translations, source media, and downloaded file references.

## `mediaFiles` (type: `string`):

Pictures and direct video files saved to the default key-value store.

# 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": [
        "https://bravelittleones.com/products/cookies-and-milk-zip-romper"
    ],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "most_recent",
    "filterLanguages": [],
    "translationTarget": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/shopify-judge-me-reviews-scraper-api").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": ["https://bravelittleones.com/products/cookies-and-milk-zip-romper"],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "most_recent",
    "filterLanguages": [],
    "translationTarget": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/shopify-judge-me-reviews-scraper-api").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": [
    "https://bravelittleones.com/products/cookies-and-milk-zip-romper"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "most_recent",
  "filterLanguages": [],
  "translationTarget": "en"
}' |
apify call lurkapi/shopify-judge-me-reviews-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/wXbpSjOvpFxf2qPOm/builds/l1xC8rX58XZcPOVZl/openapi.json