# Shopify Yotpo Reviews Scraper API (`lurkapi/shopify-yotpo-reviews-scraper-api`) Actor

Scrape exact-product Yotpo reviews from Shopify product URLs or scan store sitemaps for product ratings and review counts.

- **URL**: https://apify.com/lurkapi/shopify-yotpo-reviews-scraper-api.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Agents, Automation, E-commerce
- **Stats:** 3 total users, 2 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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Yotpo Reviews Scraper API

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

### 🎬 What it does

Paste a Shopify store URL or a product URL. Get back reviews in a spreadsheet.

Two kinds of input:

1. **Store URL** returns one summary row per public product on the store, including SKUs sitting at zero reviews. Good for catalog-wide dashboards, launch-week rating sweeps, and spotting the quiet products in your own store.
2. **Product URL** returns every individual review on that exact 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. Sort by featured, newest, oldest, highest rating, lowest rating, most helpful, or most down-voted.
- **Paid keyword search**: pull only reviews mentioning a phrase like "refund", "sizing", or "gift".
- **Paid verified, media, incentive, and reply filters**: verified buyers only, photos only, videos only, either type of media, only or excluding incentivized reviews, or only reviews the store has publicly replied to.
- **Paid date, content, and language filters**: narrow to a date window, keep only written reviews or only ratings without text, or the set of languages you actually read.
- **Paid country, variant, and topic filters**: keep only reviewers from a country, only reviews on a variant, or only reviews about a topic Yotpo tagged.
- **Paid custom sorts**: push photo reviews or video reviews to the top of the export.
- **Paid enrichments**: tag each review with a detected language, translate reviews into your chosen language, and archive photo or video files to your run storage.

Duplicate URLs collapse automatically, so a store URL and one of its product URLs in the same run never charges you twice. Status rows like `no_products_found` are always free.

Good for: Shopify founders watching their own reviews week over week, CMOs auditing a rival'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. Duplicates are cleaned up so you never pay twice for the same store or product.

- **Store URL**: `https://www.lacrosseunlimited.com/`
- **Product URL**: `https://www.lacrosseunlimited.com/products/stringking-mark-2v-lacrosse-head-unstrung`

Minimum input, run as-is:

```json
{
  "startUrls": [
    "https://www.lacrosseunlimited.com/",
    "https://www.lacrosseunlimited.com/products/stringking-mark-2v-lacrosse-head-unstrung"
  ],
  "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 (sent straight to Yotpo):

- **Star rating filter**: keep any combination of 1 to 5 stars.
- **Sort order**: Featured, Newest, Oldest, Highest rating, Lowest rating, Most helpful, or Most down-voted.

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

- **Keyword search**: only reviews whose title or text contains your phrase.
- **Verified only**: only reviews Yotpo marks as verified.
- **Media filters**: only reviews with a photo, only with a video, or only with either.
- **Store-reply only**: only reviews the merchant has publicly replied to.
- **Incentivized filter**: keep only incentivized reviews, or exclude them.
- **Date range**: only reviews posted between two dates.
- **Written vs rating-only**: only reviews with text, or only star-ratings without text.
- **Language, country, variant, and topic filters**: only the review flavors you want.
- **Pictures-first or videos-first sort**: push reviews with photos (or with videos) to the top.
- **Language detection**: adds a language tag when Yotpo did not include one, billed only when detection succeeds.
- **Translation**: translates the review title and text into your chosen language, billed only when a translation is returned.
- **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. Anything else is a plain-English message like `no_products_found` or `yotpo_not_detected`, so you can spot and fix problems without reading the logs. Explanatory 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 |
|---|---|---|
| Review | **$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 a paid filter kept |
| Add-on: Custom sort | **$0.50 per 1,000 rows** | per delivered review from a pictures-first or videos-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 Yotpo sorts, source photo and video URLs, Yotpo's own translations, and status rows are all free.

### 💡 Good to know

- **Exact-product only**. Reviews borrowed from grouped, syndicated, bundled, or related products are never returned as though they belonged to the requested product. If ownership cannot be verified safely, you get a clear status row instead of guesswork.
- **Zero-review products are included** on store scans. Your catalog view stays complete.
- **Dedup is automatic**. The same store or product reached through several URL variants is fetched once.
- **Post-fetch scan cap**. Sorts and filters that need a complete review scan are bounded at 50,000 source reviews per product. If a complete result cannot be guaranteed, you get an uncharged `review_scan_limit_exceeded` row instead of a silently incomplete result.
- **Not on Yotpo?** If the store runs a different review widget, the status row tells you which sibling tool to run.
- **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, the field comes back `null`. Fields you toggle off are omitted from the row entirely.
- **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 Yotpo or Shopify account?**
No. Only publicly published storefront and review data is read.

**What if a store does not use Yotpo?**
You get one uncharged status row that explains it. When the actor spots a supported sibling widget on the store, the row names the matching tool to run instead.

**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 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 Yotpo and whose public 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 Judge.me Reviews Scraper API](https://apify.com/lurkapi/shopify-judge-me-reviews-scraper-api): same job for stores running Judge.me.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with Shopify's and Yotpo'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, yotpo reviews, shopify review scraper, yotpo 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 specific product URL to get every Yotpo review on that exact product. Both types 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`):

Yotpo's built-in orders (featured, date, rating, helpful) are free. Pictures-first and videos-first are custom sorts computed by the actor and count as add-ons.

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

Only keep reviews whose title or body contains this phrase. Charged only on matching rows that are delivered.

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

Only keep reviews Yotpo marks as verified purchases.

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

Only keep reviews that include at least one photo or video.

## `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 that already have a public reply from the merchant.

## `incentivizedReviews` (type: `string`):

Keep every review, only reviews Yotpo marks as incentivized (loyalty points, gift, discount), or exclude those entirely.

## `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 in these languages. Use ISO codes such as en, eng, es, spa, or pt-BR. Region tags (pt-BR, en-US) match the base language too.

## `filterCountries` (type: `array`):

Only keep reviews from these countries. Use two-letter codes such as us, ca, or gb. Applied only when Yotpo reports a country.

## `filterVariants` (type: `array`):

Only keep reviews whose Yotpo variant tag contains one of these values (color, size, edition, etc.). Case-insensitive substring match.

## `filterTopics` (type: `array`):

Only keep reviews whose Yotpo topic tags contain one of these values (comfort, quality, fit, etc.). Case-insensitive substring match.

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

When Yotpo does not return a language for a review, the actor detects one and adds a detectedLanguage field. Charged only when detection succeeds.

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

Translate the review title and body into your chosen target language. Charged only when a translation is returned.

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

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

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

Save up to 10 verified photos or videos per review (max 3 MB each) to the run's key-value store. Original source URLs stay in the row either way. Charged per file successfully stored.

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

Normalized store host, for example brooklinen.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`):

Yotpo's product-level average rating.

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

Total number of Yotpo reviews on the product.

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

Review counts broken down by star rating.

## `outputReviewTitle` (type: `boolean`):

Public review title.

## `outputReviewer` (type: `boolean`):

Public reviewer name, ID, and type (user, guest, syndicated, etc.).

## `outputSourceReferences` (type: `boolean`):

Yotpo's source review ID and source URL when supplied.

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

Timestamp when the review was posted.

## `outputVotes` (type: `boolean`):

Up-vote and down-vote counts from other shoppers.

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

Yotpo's verified-purchase flag on each review.

## `outputIncentive` (type: `boolean`):

Yotpo's incentivized flag and incentive type (loyalty points, gift, discount).

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

Public reply the merchant posted to the review.

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

Source URLs for customer photos and videos on each review.

## `outputSourceLanguage` (type: `boolean`):

Language code Yotpo reports for the review.

## `outputSentiment` (type: `boolean`):

Numeric sentiment score Yotpo reports, when supplied.

## `outputCountry` (type: `boolean`):

Two-letter country code Yotpo reports for the reviewer, when supplied.

## `outputTopics` (type: `boolean`):

Yotpo's own review topic tags (comfort, quality, fit, etc.).

## `outputCustomFields` (type: `boolean`):

Answers to Yotpo's custom questions the store added to its review form.

## `outputProductVariants` (type: `boolean`):

Variant tags Yotpo attaches to the review (color, size, edition, etc.).

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

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

## Actor input object example

```json
{
  "startUrls": [
    "https://www.lacrosseunlimited.com/products/stringking-mark-2v-lacrosse-head-unstrung"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "featured",
  "verifiedOnly": false,
  "onlyWithMedia": false,
  "onlyWithPhotos": false,
  "onlyWithVideos": false,
  "merchantReplyOnly": false,
  "incentivizedReviews": "all",
  "reviewContent": "all",
  "filterLanguages": [],
  "filterCountries": [],
  "filterVariants": [],
  "filterTopics": [],
  "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,
  "outputReviewTitle": true,
  "outputReviewer": true,
  "outputSourceReferences": true,
  "outputPublishedAt": true,
  "outputVotes": true,
  "outputVerifiedBuyer": true,
  "outputIncentive": true,
  "outputReply": true,
  "outputMediaUrls": true,
  "outputSourceLanguage": true,
  "outputSentiment": true,
  "outputCountry": true,
  "outputTopics": true,
  "outputCustomFields": true,
  "outputProductVariants": true,
  "outputInputUrl": true
}
```

# Actor output Schema

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

Compact mixed view of all product, review, and explanatory rows.

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

Product rating summaries returned from store URL inputs.

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

Individual exact-product Yotpo reviews returned from product URLs.

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

Source language, local detection, translations, media URLs, and archived file references.

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

Review pictures and direct video files archived by this run.

# 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://www.lacrosseunlimited.com/products/stringking-mark-2v-lacrosse-head-unstrung"
    ],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "featured",
    "filterLanguages": [],
    "filterCountries": [],
    "filterVariants": [],
    "filterTopics": [],
    "translationTarget": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/shopify-yotpo-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://www.lacrosseunlimited.com/products/stringking-mark-2v-lacrosse-head-unstrung"],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "featured",
    "filterLanguages": [],
    "filterCountries": [],
    "filterVariants": [],
    "filterTopics": [],
    "translationTarget": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/shopify-yotpo-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://www.lacrosseunlimited.com/products/stringking-mark-2v-lacrosse-head-unstrung"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "featured",
  "filterLanguages": [],
  "filterCountries": [],
  "filterVariants": [],
  "filterTopics": [],
  "translationTarget": "en"
}' |
apify call lurkapi/shopify-yotpo-reviews-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Yotpo Reviews Scraper API",
        "description": "Scrape exact-product Yotpo reviews from Shopify product URLs or scan store sitemaps for product ratings and review counts.",
        "version": "0.0",
        "x-build-id": "bj6WTHrGc6PJ9IUUm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~shopify-yotpo-reviews-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-shopify-yotpo-reviews-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lurkapi~shopify-yotpo-reviews-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-shopify-yotpo-reviews-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lurkapi~shopify-yotpo-reviews-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-shopify-yotpo-reviews-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Store or product URLs",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Paste a Shopify store URL to get one summary row per public product (including products with zero reviews). Paste a specific product URL to get every Yotpo review on that exact product. Both types can be mixed in the same run.",
                        "items": {
                            "type": "string",
                            "maxLength": 2048
                        }
                    },
                    "maxResultsPerUrl": {
                        "title": "Maximum results per URL",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "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.",
                        "default": 50
                    },
                    "filterRatings": {
                        "title": "Star ratings",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only keep reviews with the star ratings you pick. Leave empty to include every rating. Free with the base row price.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        }
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "featured",
                            "newest",
                            "oldest",
                            "highest_rating",
                            "lowest_rating",
                            "most_helpful",
                            "least_helpful",
                            "pictures_first",
                            "videos_first"
                        ],
                        "type": "string",
                        "description": "Yotpo's built-in orders (featured, date, rating, helpful) are free. Pictures-first and videos-first are custom sorts computed by the actor and count as add-ons.",
                        "default": "featured"
                    },
                    "filterKeyword": {
                        "title": "Search review text ($)",
                        "maxLength": 500,
                        "type": "string",
                        "description": "Only keep reviews whose title or body contains this phrase. Charged only on matching rows that are delivered."
                    },
                    "verifiedOnly": {
                        "title": "Only verified buyers ($)",
                        "type": "boolean",
                        "description": "Only keep reviews Yotpo marks as verified purchases.",
                        "default": false
                    },
                    "onlyWithMedia": {
                        "title": "Only reviews with media ($)",
                        "type": "boolean",
                        "description": "Only keep reviews that include at least one photo or video.",
                        "default": false
                    },
                    "onlyWithPhotos": {
                        "title": "Only reviews with photos ($)",
                        "type": "boolean",
                        "description": "Only keep reviews that include at least one customer photo.",
                        "default": false
                    },
                    "onlyWithVideos": {
                        "title": "Only reviews with videos ($)",
                        "type": "boolean",
                        "description": "Only keep reviews that include at least one customer video.",
                        "default": false
                    },
                    "merchantReplyOnly": {
                        "title": "Only reviews with store replies ($)",
                        "type": "boolean",
                        "description": "Only keep reviews that already have a public reply from the merchant.",
                        "default": false
                    },
                    "incentivizedReviews": {
                        "title": "Incentivized reviews ($)",
                        "enum": [
                            "all",
                            "only_incentivized",
                            "exclude_incentivized"
                        ],
                        "type": "string",
                        "description": "Keep every review, only reviews Yotpo marks as incentivized (loyalty points, gift, discount), or exclude those entirely.",
                        "default": "all"
                    },
                    "filterStartDate": {
                        "title": "Published on or after ($)",
                        "type": "string",
                        "description": "Only keep reviews posted on or after this date (YYYY-MM-DD, inclusive)."
                    },
                    "filterEndDate": {
                        "title": "Published on or before ($)",
                        "type": "string",
                        "description": "Only keep reviews posted on or before this date (YYYY-MM-DD, inclusive)."
                    },
                    "reviewContent": {
                        "title": "Written vs. rating-only ($)",
                        "enum": [
                            "all",
                            "with_text",
                            "rating_only"
                        ],
                        "type": "string",
                        "description": "Keep every review, only reviews that have written text, or only star-ratings without text.",
                        "default": "all"
                    },
                    "filterLanguages": {
                        "title": "Review languages ($)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Only keep reviews in these languages. Use ISO codes such as en, eng, es, spa, or pt-BR. Region tags (pt-BR, en-US) match the base language too.",
                        "items": {
                            "type": "string",
                            "maxLength": 16
                        }
                    },
                    "filterCountries": {
                        "title": "Reviewer countries ($)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Only keep reviews from these countries. Use two-letter codes such as us, ca, or gb. Applied only when Yotpo reports a country.",
                        "items": {
                            "type": "string",
                            "maxLength": 2
                        }
                    },
                    "filterVariants": {
                        "title": "Product variants ($)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Only keep reviews whose Yotpo variant tag contains one of these values (color, size, edition, etc.). Case-insensitive substring match.",
                        "items": {
                            "type": "string",
                            "maxLength": 100
                        }
                    },
                    "filterTopics": {
                        "title": "Review topics ($)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Only keep reviews whose Yotpo topic tags contain one of these values (comfort, quality, fit, etc.). Case-insensitive substring match.",
                        "items": {
                            "type": "string",
                            "maxLength": 100
                        }
                    },
                    "detectLanguage": {
                        "title": "Detect review language ($)",
                        "type": "boolean",
                        "description": "When Yotpo does not return a language for a review, the actor detects one and adds a detectedLanguage field. Charged only when detection succeeds.",
                        "default": false
                    },
                    "translateReviews": {
                        "title": "Translate reviews ($)",
                        "type": "boolean",
                        "description": "Translate the review title and body into your chosen target language. Charged only when a translation is returned.",
                        "default": false
                    },
                    "translationTarget": {
                        "title": "Translate into",
                        "maxLength": 16,
                        "type": "string",
                        "description": "Target language for translations. Use a code such as en, es, fr, de, ja, or pt-BR.",
                        "default": "en"
                    },
                    "downloadMedia": {
                        "title": "Archive review media ($)",
                        "type": "boolean",
                        "description": "Save up to 10 verified photos or videos per review (max 3 MB each) to the run's key-value store. Original source URLs stay in the row either way. Charged per file successfully stored.",
                        "default": false
                    },
                    "outputStoreDomain": {
                        "title": "Store domain",
                        "type": "boolean",
                        "description": "Normalized store host, for example brooklinen.com.",
                        "default": true
                    },
                    "outputStoreUrl": {
                        "title": "Store URL",
                        "type": "boolean",
                        "description": "Full canonical URL of the store's home page.",
                        "default": true
                    },
                    "outputProductHandle": {
                        "title": "Product handle",
                        "type": "boolean",
                        "description": "The URL slug Shopify uses in product paths.",
                        "default": true
                    },
                    "outputProductTitle": {
                        "title": "Product title",
                        "type": "boolean",
                        "description": "Public product name.",
                        "default": true
                    },
                    "outputProductUrl": {
                        "title": "Product URL",
                        "type": "boolean",
                        "description": "Canonical link to the product page.",
                        "default": true
                    },
                    "outputProductImageUrl": {
                        "title": "Product image",
                        "type": "boolean",
                        "description": "URL of the primary product image.",
                        "default": true
                    },
                    "outputProductDescription": {
                        "title": "Product description",
                        "type": "boolean",
                        "description": "Plain-text product description (product-summary rows only).",
                        "default": true
                    },
                    "outputPrice": {
                        "title": "Product price",
                        "type": "boolean",
                        "description": "Public price shown on the storefront.",
                        "default": true
                    },
                    "outputCurrency": {
                        "title": "Currency",
                        "type": "boolean",
                        "description": "Storefront currency code, when it can be detected.",
                        "default": true
                    },
                    "outputAvailable": {
                        "title": "Availability",
                        "type": "boolean",
                        "description": "Whether the product is publicly for sale.",
                        "default": true
                    },
                    "outputAverageRating": {
                        "title": "Average rating",
                        "type": "boolean",
                        "description": "Yotpo's product-level average rating.",
                        "default": true
                    },
                    "outputReviewCount": {
                        "title": "Review count",
                        "type": "boolean",
                        "description": "Total number of Yotpo reviews on the product.",
                        "default": true
                    },
                    "outputRatingHistogram": {
                        "title": "Rating histogram",
                        "type": "boolean",
                        "description": "Review counts broken down by star rating.",
                        "default": true
                    },
                    "outputReviewTitle": {
                        "title": "Review title",
                        "type": "boolean",
                        "description": "Public review title.",
                        "default": true
                    },
                    "outputReviewer": {
                        "title": "Reviewer details",
                        "type": "boolean",
                        "description": "Public reviewer name, ID, and type (user, guest, syndicated, etc.).",
                        "default": true
                    },
                    "outputSourceReferences": {
                        "title": "Source references",
                        "type": "boolean",
                        "description": "Yotpo's source review ID and source URL when supplied.",
                        "default": true
                    },
                    "outputPublishedAt": {
                        "title": "Review date",
                        "type": "boolean",
                        "description": "Timestamp when the review was posted.",
                        "default": true
                    },
                    "outputVotes": {
                        "title": "Helpful votes",
                        "type": "boolean",
                        "description": "Up-vote and down-vote counts from other shoppers.",
                        "default": true
                    },
                    "outputVerifiedBuyer": {
                        "title": "Verified buyer flag",
                        "type": "boolean",
                        "description": "Yotpo's verified-purchase flag on each review.",
                        "default": true
                    },
                    "outputIncentive": {
                        "title": "Incentive details",
                        "type": "boolean",
                        "description": "Yotpo's incentivized flag and incentive type (loyalty points, gift, discount).",
                        "default": true
                    },
                    "outputReply": {
                        "title": "Merchant reply",
                        "type": "boolean",
                        "description": "Public reply the merchant posted to the review.",
                        "default": true
                    },
                    "outputMediaUrls": {
                        "title": "Media URLs",
                        "type": "boolean",
                        "description": "Source URLs for customer photos and videos on each review.",
                        "default": true
                    },
                    "outputSourceLanguage": {
                        "title": "Source language",
                        "type": "boolean",
                        "description": "Language code Yotpo reports for the review.",
                        "default": true
                    },
                    "outputSentiment": {
                        "title": "Source sentiment",
                        "type": "boolean",
                        "description": "Numeric sentiment score Yotpo reports, when supplied.",
                        "default": true
                    },
                    "outputCountry": {
                        "title": "Reviewer country",
                        "type": "boolean",
                        "description": "Two-letter country code Yotpo reports for the reviewer, when supplied.",
                        "default": true
                    },
                    "outputTopics": {
                        "title": "Review topics",
                        "type": "boolean",
                        "description": "Yotpo's own review topic tags (comfort, quality, fit, etc.).",
                        "default": true
                    },
                    "outputCustomFields": {
                        "title": "Custom fields",
                        "type": "boolean",
                        "description": "Answers to Yotpo's custom questions the store added to its review form.",
                        "default": true
                    },
                    "outputProductVariants": {
                        "title": "Product variants",
                        "type": "boolean",
                        "description": "Variant tags Yotpo attaches to the review (color, size, edition, etc.).",
                        "default": true
                    },
                    "outputInputUrl": {
                        "title": "Input URL",
                        "type": "boolean",
                        "description": "The URL from your input that produced this row. Useful for grouping results.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
