# Judge.me Reviews Scraper — Shopify Store & Product Reviews (`memo23/judge-me-reviews-scraper`) Actor

Judge.me reviews scraper — export every review from any Shopify store running judge.me. Whole store or a single product URL, server-side sort, rating and verified-buyer filters, photos, merchant replies, plus an optional store summary with a 1-5 star histogram. Pure HTTP, no API key

- **URL**: https://apify.com/memo23/judge-me-reviews-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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

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

Export **judge.me** reviews from any Shopify store — the whole store or a single product — straight from judge.me's own public review widget. Rating, title, body, reviewer, verified-buyer flag, date, photos, merchant reply and product link, one flat row per review.

Pure HTTP. No API key, no browser, no proxy, no CAPTCHA solver.

![How the Judge.me Reviews Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-judgeme.png)

***

### Why use this scraper

- **It works on headless storefronts.** Most judge.me scrapers resolve a product through Shopify's classic `/products/{handle}.json` endpoint — which returns **404** on a Hydrogen / custom storefront. This actor reads the product id out of judge.me's own widget markup instead, so it resolves stores the others simply skip. Verified live: `owalalife.com/products/freesip.json` → 404, this actor → 15 reviews in 18 seconds.
- **Whole store or one product, auto-detected.** Paste a homepage, a collection page or a bare domain to walk the store's review feed; paste a `/products/{handle}` URL to scope to that product. Mix both in one run.
- **Sorting happens on judge.me's side.** `newest`, `highest_rating`, `lowest_rating`, `most_helpful` are passed through to the API — so "give me this store's 200 worst reviews" is one cheap run, not a full export you filter afterwards.
- **Filters are free.** Rating and verified-buyer filtering runs *before* a row is written, so filtered-out reviews never count toward your item cap and are never billed.
- **The fields people actually want.** Photos, merchant replies, thumbs up/down, the verified-buyer flag and judge.me's transparency badge (which marks reviews imported from another provider) — not just a star count and a string.
- **Optional store summary.** One extra row per store with total review counts and a 1–5 star frequency histogram: a competitor's whole reputation profile without paging through 60,000 reviews.
- **No wasted spend.** A run started with no usable input stops before the first HTTP request and writes nothing to the dataset, so it bills no rows.

***

### Overview

The output is **flat, one row per review** — not one row per store with a nested reviews array. That makes it drop straight into a spreadsheet, a warehouse table or a sentiment pipeline without unnesting.

Two row shapes land in the same dataset, tagged by a `type` field:

| `type` | What it is | How many |
|---|---|---|
| `review` | A single judge.me review | One per review collected |
| `store_summary` | Review counts + 1–5 star histogram for a store | One per whole-store target, only when `includeStoreSummary` is on |

Filter on `type` downstream if you want them separated.

***

### Supported inputs

| Input shape | Example | What you get |
|---|---|---|
| Store homepage / any store page | `https://deathwishcoffee.com` | The store's shop-wide review feed (store-level and product-level reviews mixed) |
| Bare domain | `deathwishcoffee.com` | Same — `https://` is added for you |
| `*.myshopify.com` host | `owala.myshopify.com` | Same, and it skips the domain-resolution fetch entirely |
| Product URL | `https://owalalife.com/products/freesip` | Only that product's reviews |
| Explicit `shopDomains` entry | `owala.myshopify.com` | Same as a store URL, resolution skipped |

**One thing worth knowing about headless stores.** A store URL is resolved by reading the shop's `myshopify.com` identity out of the page. Classic Liquid themes publish it on every page, including the homepage. Fully headless storefronts (Hydrogen and friends) publish it only where judge.me's widget renders — the product pages. So for a headless store, hand it a **product URL** or the store's **`*.myshopify.com` domain** rather than the marketing homepage.

**Not supported:** stores that do not have judge.me installed (each such target is reported in the log with the reason and skipped, rather than silently returning zero rows), judge.me's separate Q\&A feature, and anything behind a judge.me merchant login — this actor only reads the public widget.

***

### Use cases

| You are a… | Use it to… |
|---|---|
| DTC / ecommerce brand | Pull your own store's reviews into BI, a warehouse or a CRM without a paid judge.me API tier |
| Competitive analyst | Snapshot a rival's rating histogram, then read their newest and their 1-star reviews |
| Agency or consultant | Bulk-export reviews across a client's catalogue for a UGC or testimonial audit |
| Product / CX team | Feed real customer wording into a sentiment or topic model |
| Lead-gen researcher | Pair with a Shopify-store discovery tool: find stores → measure review volume and sentiment |

***

### How it works

1. **Classify.** Each input is sorted into a product target (`/products/{handle}`) or a store target (everything else). `shopDomains` entries are always store targets.
2. **Resolve.** One fetch of the target page yields both the judge.me `shop_domain` and — for product URLs — the numeric product id, taken from the review widget's own `data-id` attribute. A `*.myshopify.com` input skips this fetch entirely.
3. **Walk.** The public review endpoint is paginated (20 reviews per page, judge.me's own server-side cap) until the store's review ceiling, a page with no unseen reviews, or your per-URL cap is reached.
4. **Parse.** Each review block is turned into a flat row. Two different judge.me widget generations are handled, so both older and current stores parse correctly.
5. **Filter.** Rating and verified-buyer rules are applied before a row is emitted — dropped rows cost nothing.
6. **Emit.** One row per review, deduplicated by judge.me's review id, plus the optional store-summary row.

***

### Input configuration

| Field | Type | Default | Notes |
|---|---|---|---|
| `startUrls` | array of strings | `[]` | Store or product URLs, auto-classified. Mix freely. |
| `shopDomains` | array of strings | `[]` | Advanced. Explicit `xxx.myshopify.com` values; skips resolution. Always whole-store. |
| `maxItems` | integer | `100` | **Per URL**, not per run — each target gets its own allowance. |
| `sortBy` | select | `newest` | `newest`, `highest_rating`, `lowest_rating`, `most_helpful`. Applied by judge.me. |
| `ratingFilter` | array of strings | `[]` | Keep only these exact star ratings, e.g. `["1"]`. Empty = all ratings. |
| `verifiedOnly` | boolean | `false` | Keep only judge.me verified-buyer reviews. |
| `includeStoreSummary` | boolean | `true` | Emit the extra summary row per whole-store target. |
| `maxConcurrency` | integer | `5` | Store/product targets processed in parallel. |
| `proxy` | object | none | Leave empty. No proxy is used by default — the endpoint has no anti-bot. |

At least one of `startUrls` or `shopDomains` must be set. If both are empty the run stops immediately, writes a `INPUT_GUARD` record to the key-value store explaining what was missing, and bills no rows.

#### Example input

```json
{
  "startUrls": [
    "https://owalalife.com",
    "https://owalalife.com/products/freesip"
  ],
  "maxItems": 200,
  "sortBy": "lowest_rating",
  "ratingFilter": ["1", "2"],
  "verifiedOnly": true,
  "includeStoreSummary": true
}
```

***

### Output overview

Every review row carries the review itself, its author, its engagement signals, its media, the merchant's reply, and the product and store it belongs to. Every value below comes from a real run — no invented samples.

### Output samples

#### `type: "review"` — a real 1-star review with a merchant reply

```json
{
  "type": "review",
  "reviewId": "58bdca57-7160-4c09-889b-9f6b38c51fde",
  "rating": 1,
  "title": "Shipping concerns",
  "body": "Since seeing these bottles online i decided to order my own with 2-3 days shipping i was excited to receive my bottle however after a week since ordering my bottle my tracking is still waiting on owala to give the bottle to the shipping company. I am very disappointed with this issue as it has been difficult to submit a real complaint as the ai helper seems to offer no real solution",
  "reviewerName": "Adam",
  "reviewerLocation": null,
  "verifiedBuyer": true,
  "reviewDate": "2026-08-11T09:58:40.000Z",
  "reviewLanguage": null,
  "photos": [],
  "videos": [],
  "merchantReply": "We are sorry to hear about any issues you have run into with order! For shipping or fulfillment related concerns, we recommend filing a claim through Order Protection directly to receive an immediate resolution...",
  "thumbsUp": 5,
  "thumbsDown": 3,
  "sourceBadge": "review_collected_from_store_visitor",
  "productTitle": "FreeSip UK",
  "productUrl": "https://checkout.owalalife.com/products/freesip-uk",
  "storeUrl": "https://owalalife.com/products/freesip",
  "shopDomain": "owala.myshopify.com",
  "scrapedAt": "2026-08-12T20:20:27.435Z"
}
```

#### `type: "store_summary"` — one per whole-store target

```json
{
  "type": "store_summary",
  "totalShopReviews": 408,
  "totalProductReviews": 67351,
  "averageRating": 4.55,
  "ratingHistogram": {
    "1": { "frequency": 4157, "percentage": 6 },
    "2": { "frequency": 1704, "percentage": 3 },
    "3": { "frequency": 2359, "percentage": 3 },
    "4": { "frequency": 3829, "percentage": 6 },
    "5": { "frequency": 55727, "percentage": 82 }
  },
  "storeUrl": "https://owala.myshopify.com",
  "shopDomain": "owala.myshopify.com",
  "scrapedAt": "2026-08-12T20:16:36.735Z"
}
```

### Key output fields

**The review**

| Field | Notes |
|---|---|
| `reviewId` | judge.me's own id for the review — stable, use it as your primary key |
| `rating` | 1–5 |
| `title` | Often `null` — judge.me does not require a title |
| `body` | The review text |
| `reviewDate` | ISO 8601 UTC, normalised from two different widget date formats |
| `reviewLanguage` | Two-letter code where judge.me records one, else `null` |

**The reviewer and trust signals**

| Field | Notes |
|---|---|
| `reviewerName` | First name or display name as shown on the widget |
| `reviewerLocation` | Populated only on stores that collect it |
| `verifiedBuyer` | judge.me's verified-purchase flag |
| `sourceBadge` | judge.me transparency badge — e.g. `review_collected_from_store_visitor`, `review_written_in_shop_app`, `review_collected_from_another_provider` (imported from AliExpress/Amazon/etc), or `null` for a plain organic review |
| `thumbsUp` / `thumbsDown` | Helpfulness votes |

**Media and merchant response**

| Field | Notes |
|---|---|
| `photos` | Array of full-size image URLs on `review-images.judgeme.com` |
| `videos` | Array of video URLs; best-effort — most stores have none |
| `merchantReply` | The store's public reply text, or `null` |

**Context**

| Field | Notes |
|---|---|
| `productTitle` / `productUrl` | The reviewed product. `null` on store-level reviews, which judge.me supports alongside product reviews |
| `storeUrl` | The URL you supplied for this target |
| `shopDomain` | The resolved `xxx.myshopify.com` domain |
| `scrapedAt` | ISO timestamp of collection |

**Store summary**

| Field | Notes |
|---|---|
| `totalShopReviews` | Count of store-level (not product-specific) reviews |
| `totalProductReviews` | Count of product reviews across the whole catalogue |
| `ratingHistogram` | Per-star `frequency` and `percentage` |
| `averageRating` | Weighted average across the histogram's numeric buckets (judge.me's unrated bucket is excluded from the average but kept in `ratingHistogram`) |

***

### Pricing

Pay per event. No monthly rental.

| Event | Charged when | Price |
|---|---|---|
| Actor start | Once, when a run starts | $0.00005 |
| Review record | Per row written to the dataset | $0.0012 |
| Store summary record | Extra charge on top of the review-record price when a store-summary row is emitted | $0.002 |

So 1,000 reviews cost about **$1.20**, and each store-summary row costs $0.0032 in total. Turn `includeStoreSummary` off if you only want the reviews.

Reviews dropped by `ratingFilter` or `verifiedOnly` are never written and never billed. A run with no usable input writes no rows at all.

***

### FAQ

**Do I need judge.me API credentials?** No. This reads the same public, unauthenticated widget endpoint that every storefront's review widget calls in a visitor's browser. There is no `api_token` anywhere in the actor.

**Do I need a proxy?** No. The endpoint showed no anti-bot behaviour in testing and works from ordinary datacenter IPs, so no proxy is used by default. The `proxy` input is there if you ever want to route through your own pool.

**What if the store does not use judge.me?** That target is skipped with an explicit reason in the log ("could not resolve a judge.me shop\_domain") instead of silently returning nothing. Other targets in the same run continue normally.

**My store has a custom domain and a headless frontend. Will it work?** Yes — that is the case this actor is built for. The product id comes from judge.me's own widget block, which renders regardless of whether the storefront is Liquid, Hydrogen or fully custom. Point it at a **product URL** or the store's **`*.myshopify.com` domain**; a headless marketing homepage often carries no Shopify identity at all, so it is the one input shape that can fail to resolve.

**Why is `productTitle` sometimes `null`?** judge.me supports store-level reviews that are not attached to any product. Those rows have no product context. Product-scoped runs always have it.

**Can I get only the 1-star reviews?** Yes. Set `ratingFilter: ["1"]`, and set `sortBy: "lowest_rating"` so judge.me serves them first. Filtered-out reviews are free.

**Is `maxItems` per run or per URL?** Per URL. Five store URLs with `maxItems: 100` can produce up to 500 review rows. The run's overall charge limit, set in the Apify console, is the global ceiling that always wins.

**Are reviews deduplicated?** Yes, by judge.me's review id within each target, and pagination stops as soon as a page contains nothing new.

***

### Support

Found a store it cannot resolve, or a field you need added? Open an issue on the actor's **Issues** tab in Apify Console with the store URL you tried — that is the fastest path to a fix.

### Additional services

Need this shaped to your pipeline — a different row schema, a scheduled incremental feed, a webhook into your warehouse, or the same data joined with another source? Custom scraper work is available; open an issue or message through the Apify platform to discuss it.

### Explore more scrapers

More review and directory scrapers from the same developer on the Apify Store — [apify.com/memo23](https://apify.com/memo23):

- **Capterra Scraper** — software products, reviews, categories and alternatives
- **G2 Scraper** — B2B software reviews and category rankings
- **Yelp Scraper** — local business listings and reviews
- **Kununu Scraper** — DACH employer reviews, salaries and jobs
- **ReclameAqui Scraper** — Brazilian consumer complaints

***

### 🤖 For AI Agents & LLM Apps

**Purpose:** Extracts judge.me product and store reviews from any Shopify storefront that has the judge.me app installed. Whole-store or single-product.

**Minimal tested input:**

```json
{ "shopDomains": ["owala.myshopify.com"], "maxItems": 25 }
```

**Input fields:** `startUrls` (string\[], store or `/products/{handle}` URLs), `shopDomains` (string\[], `*.myshopify.com`), `maxItems` (int, per URL, default 100), `sortBy` (`newest` | `highest_rating` | `lowest_rating` | `most_helpful`), `ratingFilter` (string\[] of `"1"`–`"5"`), `verifiedOnly` (bool), `includeStoreSummary` (bool, default true), `maxConcurrency` (int), `proxy` (object, optional).

**Output fields — `type: "review"`:** `type`, `reviewId`, `rating`, `title`, `body`, `reviewerName`, `reviewerLocation`, `verifiedBuyer`, `reviewDate`, `reviewLanguage`, `photos[]`, `videos[]`, `merchantReply`, `thumbsUp`, `thumbsDown`, `sourceBadge`, `productTitle`, `productUrl`, `storeUrl`, `shopDomain`, `scrapedAt`.

**Output fields — `type: "store_summary"`:** `type`, `totalShopReviews`, `totalProductReviews`, `averageRating`, `ratingHistogram`, `storeUrl`, `shopDomain`, `scrapedAt`.

**Billing:** $0.00005 per run start, $0.0012 per dataset row, plus $0.002 extra on each `store_summary` row. Rows removed by `ratingFilter`/`verifiedOnly` are not written and not billed.

**Agent-relevant behaviour:**

- `maxItems` is per input URL, not per run. Budget accordingly.
- Empty `startUrls` **and** empty `shopDomains` → the run exits immediately, writes an `INPUT_GUARD` record to the key-value store, and pushes no dataset rows.
- A target with no judge.me installation is skipped, not fatal; check the run log and `targetsFailed` in the stats line.
- No credentials, no proxy and no browser are required.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Judge.me, Shopify Inc., or any of their subsidiaries or affiliates. All trademarks are the property of their respective owners.

The Actor accesses only judge.me's own public review widget endpoint — the same unauthenticated, publicly served data that every storefront's review widget loads in an ordinary visitor's browser. It does not use private API tokens, authenticated endpoints, or any content behind a login, and it does not bypass access controls.

Users are responsible for ensuring their use complies with judge.me's and Shopify's Terms of Service, applicable data-protection law (GDPR, CCPA and equivalents), copyright in review content, and their own contractual obligations. Review text and reviewer names are personal data in many jurisdictions — handle them accordingly, and do not use the output to identify, profile or contact individual reviewers without a lawful basis. No scraped data is stored by the Actor's authors; results go directly to your own Apify dataset.

***

### SEO Keywords

judge.me scraper, judge.me reviews scraper, scrape judge.me reviews, judge.me api alternative, judge.me export, judgeme review export, shopify reviews scraper, shopify product reviews export, shopify store reviews scraper, shopify review api, hydrogen storefront scraper, ecommerce reviews scraper, product review data extraction, verified buyer reviews, review rating histogram, review sentiment data, ugc review export, competitor review analysis, dtc brand research, judge.me json export, judge.me csv export, apify judge.me scraper

# Actor input Schema

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

One or more Shopify storefront URLs, classified independently so you can mix whole-store and single-product targets in one run. A URL ending in `/products/{handle}` (e.g. `https://owalalife.com/products/freesip`) returns only that product's reviews; anything else (homepage, collection page, bare domain such as `deathwishcoffee.com`, or a `*.myshopify.com` host) returns the store's shop-wide review feed. Note for HEADLESS storefronts (Hydrogen/custom): the marketing homepage often carries no Shopify identity, so use a product URL or the store's `*.myshopify.com` domain instead. Default: empty — but at least one of this field or "shop\_domain values" must be set.

## `shopDomains` (type: `array`):

Explicit `xxx.myshopify.com` hosts, e.g. `owala.myshopify.com`. Each one skips the shop-domain-resolution fetch and is always treated as a whole-store target. Optional — most users should use "Store or product URLs" above instead. Default: empty.

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

Order judge.me returns reviews in — applied server-side, so `lowest_rating` with a small "Maximum reviews per URL" is a cheap way to read only a store's worst reviews. One of: `newest`, `highest_rating`, `lowest_rating`, `most_helpful`. Example: `lowest_rating`. Default: `newest`.

## `ratingFilter` (type: `array`):

Keep only reviews whose star rating is exactly one of these values. Valid values: "1", "2", "3", "4", "5". Example: \["5","1"] keeps 5-star and 1-star reviews only. Filtered-out reviews are never written to the dataset, never billed, and never count toward "Maximum reviews per URL". Default: empty (all ratings 1-5).

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

When true, keeps only reviews judge.me marks as written by a verified buyer (the widget's `data-verified-buyer` flag). Like the rating filter, excluded reviews are never written or billed. Example: true. Default: false.

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

When true, each whole-store target also emits one row with `type: "store_summary"` carrying the store-level and product-level review counts, a 1-5 star rating histogram (frequency + percentage) and a weighted average rating. That row is billed as an extra $0.005 event on top of the normal per-row price. Set to false if you only want the reviews. Default: true.

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

Hard cap on reviews collected from EACH target URL/domain — not a whole-run total. Example: 5 store URLs with a value of 100 can produce up to 500 review rows. Some stores hold tens of thousands of reviews, so raise this deliberately. The run's overall charge limit is a separate global ceiling that always wins. Minimum 1, default 100.

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

How many store/product targets are processed in parallel. Raise it for a long list of stores, lower it to be gentler. Example: 10. Minimum 1, default 5.

## `minConcurrency` (type: `integer`):

Minimum number of parallel HTTP tasks. Only used by the Crawlee fallback engine; ignored in the default mode. Minimum 1, default 1.

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried before that target is given up. Only used by the Crawlee fallback engine; the default engine has its own 4-attempt retry ladder. Minimum 0, default 5.

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

Leave this off. judge.me's public widget API has no anti-bot and works fine from any datacenter IP, so no proxy is used by default and the run is cheaper and faster without one. Only enable it if judge.me starts rate-limiting your IP, or you want to route through your own pool. Default: `{ "useApifyProxy": false }`.

## Actor input object example

```json
{
  "startUrls": [
    "owala.myshopify.com",
    "https://owalalife.com/products/freesip"
  ],
  "shopDomains": [],
  "sortBy": "newest",
  "ratingFilter": [],
  "verifiedOnly": false,
  "includeStoreSummary": true,
  "maxItems": 100,
  "maxConcurrency": 5,
  "minConcurrency": 1,
  "maxRequestRetries": 5,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped rows in the default dataset. Every row carries a `type` discriminator — `review` rows hold rating, title, body, reviewer, verified-buyer flag, review date, photos, merchant reply and product linkage; a `store_summary` row holds the shop/product review totals, average rating and the 1-5 star histogram.

# 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": [
        "owala.myshopify.com",
        "https://owalalife.com/products/freesip"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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": [
        "owala.myshopify.com",
        "https://owalalife.com/products/freesip",
    ],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/judge-me-reviews-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": [
    "owala.myshopify.com",
    "https://owalalife.com/products/freesip"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call memo23/judge-me-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/judge-me-reviews-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/VozqihJROBOJicENy/builds/95jH8H3n4ZhggP7e7/openapi.json