# Judge.me Reviews Scraper (`automation-lab/judge-me-reviews-scraper`) Actor

Export public Judge.me store ratings, trust badges, and paginated product or shop reviews by URL, domain, or directory search.

- **URL**: https://apify.com/automation-lab/judge-me-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 66.7% 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.
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 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

## Judge.me Reviews Scraper

Export public Judge.me merchant profiles, ratings, trust badges, and paginated customer reviews from one or many stores.

Provide a Judge.me store URL, a merchant domain, or a directory search such as `coffee`.
The Actor resolves the public store profile, follows Judge.me's review pagination, applies your filters, and saves clean JSON records to the default dataset.

It runs with lightweight HTTP requests.
No Judge.me login, browser, cookies, proxy configuration, or private API key is required for the supported public pages.

### What can Judge.me Reviews Scraper do?

- Find Judge.me-powered stores from the public store directory.
- Resolve a merchant website or Judge.me review-site URL.
- Export product reviews and store-level reviews.
- Filter reviews by star rating and verified-buyer status.
- Search review text and choose the requested sort order.
- Capture stable review UUIDs for incremental pipelines.
- Save store review counts, average ratings, trust scores, and badges.
- Collect reviewer, product, media, vote, and merchant-reply fields when Judge.me displays them.
- Process up to 100 stores and 50,000 matching reviews per store in one task.

### Who is it for?

#### Ecommerce brands

Benchmark reputation, watch recent feedback, and feed verified testimonials into approved internal workflows.

#### Agencies

Export consistent review data across a portfolio of Judge.me-powered client stores without manually visiting each widget.

#### Product and market researchers

Discover merchants in a niche, compare rating volume, and study recurring product themes.

#### Data and sentiment teams

Send normalized records to a warehouse, spreadsheet, vector database, dashboard, or text-analysis pipeline.
Stable `reviewId` values make repeat exports easier to deduplicate.

### Why use this Actor?

Judge.me exposes useful public data across separate directory, store-profile, and widget surfaces.
This Actor joins those surfaces into one input and one output contract.

The implementation:

1. discovers or resolves each store;
2. obtains the store's public widget identity;
3. requests paginated review pages;
4. parses review elements structurally;
5. applies the same filters to explicit and discovered stores;
6. deduplicates reviews by Judge.me UUID;
7. saves only accepted records.

Transient timeouts, rate limits, and server errors use bounded retries with backoff.
Malformed inputs and unexpected upstream response shapes fail clearly instead of returning a misleading successful empty dataset.

### What data does it extract?

The default dataset contains two record types.
Set `includeStoreSummary` to `false` if you only want review records.

#### Store fields

| Field | Meaning |
| --- | --- |
| `recordType` | `store` |
| `storeName` | Public merchant name |
| `storeDomain` | Merchant storefront domain |
| `storeUrl` | Public merchant URL |
| `platform` | Store platform reported by Judge.me |
| `productsCount` | Product count shown by Judge.me |
| `reviewCount` | Published review count |
| `verifiedReviewCount` | Published verified-review count |
| `averageRating` | Store average rating |
| `transparencyScore` | Judge.me transparency metric when available |
| `authenticityScore` | Judge.me authenticity metric when available |
| `badges` | Public medal/badge details |
| `country`, `currency` | Store geography and currency when available |
| `sourceUrl` | Judge.me store-profile URL |

#### Review fields

| Field | Meaning |
| --- | --- |
| `recordType` | `review` |
| `reviewId` | Stable Judge.me review UUID |
| `title`, `body` | Review title and text |
| `rating` | Integer star rating from 1 to 5 |
| `verifiedBuyer` | Judge.me verified-buyer marker |
| `createdAt` | Published timestamp |
| `reviewerName`, `reviewerLocation` | Public reviewer identity fields |
| `reviewType` | `product` or `shop` |
| `productTitle`, `productUrl` | Linked product, when present |
| `mediaUrls` | Public review image/video URLs |
| `helpfulVotes`, `unhelpfulVotes` | Public vote counts |
| `merchantReply` | Merchant response text, when present |
| `transparencyBadges` | Review collection/transparency markers |
| `discoveryQuery` | Directory query that found the store, when applicable |
| `sourceUrl`, `scrapedAt` | Provenance and extraction timestamp |

Fields that Judge.me does not display for a record are omitted rather than invented.

### How to scrape Judge.me reviews

1. Open the Actor in Apify Console.
2. Add one or more `startUrls`, `storeDomains`, or `searchQueries`.
3. Choose `maxStores` and `maxReviews`.
4. Optionally select product/shop reviews, ratings, verified buyers, search text, and sort order.
5. Click **Start**.
6. Open the default dataset and export JSON, CSV, Excel, XML, or RSS.

A small source-specific input:

```json
{
  "startUrls": [
    { "url": "https://judge.me/reviews/stores/www.mysticmonkcoffee.com" }
  ],
  "maxStores": 1,
  "maxReviews": 25,
  "verifiedOnly": true,
  "includeStoreSummary": true
}
```

A discovery workflow:

```json
{
  "searchQueries": ["coffee"],
  "maxStores": 5,
  "maxReviews": 100,
  "reviewType": "product",
  "minRating": 4,
  "maxRating": 5
}
```

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | — | Judge.me review-site or merchant URLs |
| `storeDomains` | string array | `[]` | Merchant custom or platform domains |
| `searchQueries` | string array | `[]` | Terms for Judge.me's public store directory |
| `maxStores` | integer | `10` | Maximum unique stores, from 1 to 100 |
| `maxReviews` | integer | `100` | Maximum matching reviews per store, from 1 to 50,000 |
| `reviewType` | enum | `all` | `all`, `product`, or `shop` |
| `verifiedOnly` | boolean | `false` | Keep only verified-buyer reviews |
| `minRating` | integer | `1` | Minimum accepted rating |
| `maxRating` | integer | `5` | Maximum accepted rating |
| `sortBy` | enum | `most-recent` | Most recent, highest rating, or lowest rating |
| `searchText` | string | — | Optional review-text search, up to 200 characters |
| `includeStoreSummary` | boolean | `true` | Save one summary record per resolved store |

At least one URL, domain, or directory query is required.
`minRating` cannot exceed `maxRating`.
Duplicate stores and review UUIDs are removed within each run.

### Example output

This shortened record reflects real output from a public Mystic Monk Coffee review:

```json
{
  "recordType": "review",
  "storeName": "Mystic Monk Coffee",
  "storeDomain": "www.mysticmonkcoffee.com",
  "platform": "shopify",
  "reviewId": "1f78f9a3-5625-4254-ada3-f8b5264fade2",
  "title": "Huckleberry is A new favorite",
  "rating": 5,
  "verifiedBuyer": true,
  "reviewerName": "Beth F.",
  "reviewType": "product",
  "productTitle": "Huckleberry",
  "productUrl": "https://www.mysticmonkcoffee.com/products/huckleberry#judgeme_product_reviews",
  "mediaUrls": [],
  "helpfulVotes": 0,
  "unhelpfulVotes": 0,
  "transparencyBadges": ["review_collected_via_store_invitation"],
  "sourceUrl": "https://judge.me/reviews/stores/www.mysticmonkcoffee.com"
}
```

Store summaries and reviews share identifying/provenance fields so they can be joined or separated by `recordType`.

### How much does it cost to export Judge.me reviews?

The Actor uses pay-per-event pricing: a **$0.00005** one-time `start` event plus an `item` event for each dataset row it saves.
A store summary and a review are each one `item` event.
Disable `includeStoreSummary` if summary rows are not useful to your workflow.

The measured tier curve starts at **$0.000041071 per item** on the FREE tier and decreases through BRONZE, SILVER, GOLD, PLATINUM, and DIAMOND to **$0.00001 per item**.
Including the start event, 1,000 saved items cost about **$0.04112** on the FREE tier and 10,000 cost about **$0.41076**.
At higher usage tiers, the same exports cost less according to the active Console pricing table.

You are never charged for duplicate, filtered-out, empty, or failed review records.
Apify platform plan allowances and taxes are separate.
Always check the Actor's live pricing panel before a large run.

### Pagination, filters, and limits

`maxReviews` counts matching review rows per store, not fetched pages.
When strict filters are enabled, the Actor may inspect additional public pages to find enough accepted records.
It stops when the limit is reached or Judge.me returns no more reviews.

Directory search currently uses the public results Judge.me returns for the query.
`maxStores` bounds how many unique results continue to profile and review extraction.
If several queries find the same store, it is processed once.

`sortBy` and `searchText` are sent to the public widget endpoint.
Rating, verified-buyer, and review-type filters are also enforced on parsed records before charging and storage.

### Monitoring and deduplication workflow

For a recurring monitor:

1. save `reviewId` as the source key in your destination;
2. schedule the Actor daily or weekly;
3. request `most-recent` reviews;
4. upsert by `reviewId`;
5. alert only on previously unseen IDs.

The Actor deduplicates within one run.
Cross-run persistence belongs in your dataset consumer, database, or Apify integration because retention requirements differ between teams.

### Integrations

Use Apify integrations to send completed datasets to:

- Google Sheets for client reporting;
- Slack or email for review alerts;
- Make or Zapier for workflow routing;
- webhooks for ingestion jobs;
- cloud storage and data warehouses;
- sentiment, topic, or LLM classification pipelines.

For high-volume exports, consume dataset items through the API rather than copying from the Console table.

### Run with the Apify API using cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~judge-me-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "storeDomains": ["www.mysticmonkcoffee.com"],
    "maxReviews": 100,
    "verifiedOnly": true
  }'
```

The response includes a run ID and default dataset ID.
Do not commit your Apify token to source control.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/judge-me-reviews-scraper').call({
  searchQueries: ['coffee'],
  maxStores: 3,
  maxReviews: 50,
  minRating: 4,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/judge-me-reviews-scraper').call(run_input={
    'storeDomains': ['www.mysticmonkcoffee.com'],
    'maxReviews': 100,
    'reviewType': 'product',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Use Judge.me Reviews Scraper through MCP

Add the Apify MCP server to Claude Code:

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

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this equivalent MCP configuration:

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

Example prompts:

- “Find five coffee stores on Judge.me and return their ratings and review counts.”
- “Export the newest 100 verified product reviews from www.mysticmonkcoffee.com.”
- “Collect one-star and two-star Judge.me reviews for these domains and summarize recurring issues.”

### Responsible use and legality

This Actor accesses public Judge.me review-site and widget data without bypassing login controls.
Public availability does not remove your responsibilities.

- Follow Judge.me and merchant terms that apply to your use.
- Respect copyright, database rights, privacy, and consumer-protection laws.
- Do not use reviewer data for harassment, discrimination, spam, or identity enrichment.
- Collect only fields needed for a legitimate purpose.
- Apply appropriate retention, access controls, and deletion policies.
- Obtain legal advice for regulated or high-risk uses.

The Actor is a technical data-access tool, not legal advice.

### Limitations

- Judge.me can change public endpoint parameters or HTML classes.
- Deleted, hidden, moderated, or private reviews cannot be exported.
- Some reviews do not contain titles, products, media, locations, or replies.
- Search results depend on Judge.me's public directory ranking and availability.
- `searchText` behavior is controlled by the upstream public widget.
- Very large, highly filtered jobs can take longer because rejected rows are not counted toward `maxReviews`.
- The Actor does not scrape private merchant dashboards or unpublished review data.
- No proxy fallback is enabled; persistent upstream blocking fails visibly rather than creating unmeasured proxy cost.

### Troubleshooting

#### “No public Judge.me store found”

Check that the domain has a public Judge.me review-site profile.
Try the exact URL shown under `judge.me/reviews/stores/...` rather than a redirected campaign URL.

#### The run returned fewer reviews than requested

The source may be exhausted, or your rating, verification, type, and text filters may exclude most rows.
Relax one filter and compare the store's public review count.

#### The run failed with HTTP 429 or 5xx

Transient failures are retried automatically.
If Judge.me remains unavailable, wait before retrying rather than launching repeated runs.
The Actor does not require user proxy settings.

#### A review field is missing

Optional fields are emitted only when Judge.me displays them.
Use null-safe ingestion and identify records by `reviewId`, not title or reviewer name.

### Related Automation Lab Actors

- [Trustpilot Reviews Scraper](https://apify.com/automation-lab/trustpilot) for public Trustpilot business reviews.
- [G2 Scraper](https://apify.com/automation-lab/g2-scraper) for B2B software reviews and product research.
- [Shopify Store Analyzer](https://apify.com/automation-lab/shopify-store-analyzer) for broader storefront and technology intelligence.

Choose this Actor when Judge.me merchant and product reviews are the primary source.
Use the related Actors only when you need their distinct review platforms or store-intelligence records.

### FAQ

#### Does it require a Judge.me account or API key?

No.
It uses the public store directory, public store profiles, and public widget identity shown by Judge.me.
Your Apify token is needed only when launching through the Apify API.

#### Does it work for non-Shopify stores?

The Actor uses the store domain and platform identity returned by Judge.me, so it is not hard-coded to Shopify.
Coverage still depends on a public Judge.me store profile and widget endpoint.

#### Are store summaries charged separately?

They use the same `item` event as review rows; there is no separate record-type event. Each run also has the documented $0.00005 `start` event.
Set `includeStoreSummary` to `false` to omit them.

#### Can I export only product reviews?

Yes.
Set `reviewType` to `product`.
Use `shop` for store-level reviews or `all` for both.

#### Can I search for merchants instead of knowing their domains?

Yes.
Add terms to `searchQueries` and set `maxStores` to bound the directory results processed.
The output includes `discoveryQuery` for stores and reviews found that way.

#### How should I identify new reviews across runs?

Use `reviewId` as the source key and upsert in your destination.
The Actor performs in-run deduplication but does not silently maintain a cross-run customer database.

# Actor input Schema

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

Judge.me review-site URLs or merchant website URLs to scrape.

## `storeDomains` (type: `array`):

Merchant domains, such as www.mysticmonkcoffee.com or mystic-monk-coffee.myshopify.com.

## `searchQueries` (type: `array`):

Discover stores in Judge.me's public directory, for example coffee or skincare.

## `maxStores` (type: `integer`):

Maximum number of unique stores to process across all inputs.

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

Maximum matching review records to save for each store.

## `reviewType` (type: `string`):

Return all reviews, product reviews, or store-level reviews.

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

Only save reviews marked by Judge.me as verified-buyer reviews.

## `minRating` (type: `integer`):

Lowest star rating to include.

## `maxRating` (type: `integer`):

Highest star rating to include.

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

Order requested from the public Judge.me widget endpoint.

## `searchText` (type: `string`):

Optional text passed to Judge.me's review search.

## `includeStoreSummary` (type: `boolean`):

Save one store record with ratings, counts, trust scores, and badges before its reviews.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://judge.me/reviews/stores/www.mysticmonkcoffee.com"
    }
  ],
  "storeDomains": [],
  "searchQueries": [],
  "maxStores": 10,
  "maxReviews": 100,
  "reviewType": "all",
  "verifiedOnly": false,
  "minRating": 1,
  "maxRating": 5,
  "sortBy": "most-recent",
  "includeStoreSummary": true
}
```

# Actor output Schema

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

Open the default dataset table containing store summary and review records.

# 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://judge.me/reviews/stores/www.mysticmonkcoffee.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/judge-me-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://judge.me/reviews/stores/www.mysticmonkcoffee.com" }] }

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://judge.me/reviews/stores/www.mysticmonkcoffee.com"
    }
  ]
}' |
apify call automation-lab/judge-me-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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