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:

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

A discovery workflow:

{
  "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:

{
  "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

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

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

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:

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:

{
  "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 for public Trustpilot business reviews.
• G2 Scraper for B2B software reviews and product research.
• 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.