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

Scrape Junip product reviews from Shopify product URLs and site reviews from store URLs.

- **URL**: https://apify.com/lurkapi/shopify-junip-reviews-scraper-api.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** AI, Automation, E-commerce
- **Stats:** 2 total users, 1 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 Junip Reviews Scraper API

Pull public Junip product reviews and site reviews from Shopify stores into one clean spreadsheet. Collect a product's full public review group, monitor the reputation of a store, mine 1-star feedback, or build a review dataset ready to filter, analyze, and export.

### 🎬 What it does

Paste a Shopify store URL or a product URL. Get back public Junip reviews in structured rows.

Two kinds of input:

1. **Store URL** returns public Junip site reviews about the store itself. Good for reputation monitoring, service-quality analysis, and recurring brand reports.
2. **Product URL** returns the product-group reviews shown by that product's Junip widget. Good for quote pulls, product research, launch analysis, and review-history exports.

Shape the results before you pay for them:

- **Free filters and sorts**: keep any mix of 1 to 5 stars. Sort by newest, oldest, highest rating, lowest rating, most helpful, or featured first.
- **Paid keyword search**: pull only reviews mentioning a phrase such as "refund", "sizing", or "gift".
- **Paid verified, recommendation, media, and reply filters**: verified buyers only, recommended reviews only, photos only, videos only, either type of media, or reviews the store publicly replied to.
- **Paid date, length, and language filters**: narrow to a date window, require a minimum amount of written text, or keep only selected public Junip locales.
- **Paid enrichments**: translate review titles and text, and archive customer photos or videos to your run storage.

Equivalent URL variants collapse automatically. A store target and a product target remain separate because they return different kinds of Junip reviews. Explanatory status rows are always free.

Good for: Shopify founders watching brand and product feedback, CMOs auditing a launch or competitor, agencies preparing recurring client reports, researchers studying verified buyer sentiment, and analysts building review datasets they can trust.

### 📋 How to use it

#### Step 1: Paste your inputs

Drop any combination into **Store or product URLs**, one per line. Duplicate versions of the same target are cleaned up automatically.

- **Store URL**: `https://woashoes.com/`
- **Product URL**: `https://hexclad.com/products/damascus-steel-starter-knife-set-2-pc-espresso`

Minimum input, run as-is:

```json
{
  "startUrls": [
    "https://hexclad.com/products/damascus-steel-starter-knife-set-2-pc-espresso"
  ],
  "maxResultsPerUrl": 50
}
````

`maxResultsPerUrl` is the only result limit you need. The default is 50 and the maximum is 50,000. It caps site reviews for each store URL and product-group reviews for each product URL.

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

Free filters and sorts:

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

Paid add-ons are billed only when they contribute to a delivered result:

- **Keyword search**: only reviews whose title or text contains your phrase.
- **Verified only**: only reviews Junip marks as verified purchases.
- **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.
- **Recommended only**: only reviews whose author recommends the product or store.
- **Date range**: only reviews posted between two inclusive dates.
- **Minimum text length**: require a written review body of at least the selected length.
- **Language filter**: only reviews with the Junip locale codes you select.
- **Translation**: translate review titles and text into your chosen language, billed only when translated text is returned.
- **Media archiving**: save up to 10 photos or videos per product review with a 3 MB limit per file, billed only per file stored.

Use the **Output fields** section to turn off optional columns you do not need. Core status, row type, product and review IDs, rating, text, scrape time, and error fields remain available for reliable downstream processing.

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

Click **Start**. Rows stream into the Output tab as they arrive. The dataset includes four ready-made views:

- **Overview**: the most useful columns across product reviews, site reviews, and explanatory rows.
- **Product reviews**: product-group review details, reviewer signals, replies, votes, media, and exact per-row product identity.
- **Site reviews**: public store-review details, reviewer signals, replies, votes, locale, and store identity.
- **Language & Media**: public locale, survey answers, translated text, source media, and archived file references.

Every row includes a `status` and `rowType`. `status: "Success"` means the row contains a public review. `rowType` is `review` for product-group reviews, `store_review` for site reviews, or `status` for an explanation. Explanatory rows include a stable `error` code such as `invalid_url`, `junip_not_detected`, `product_unavailable`, or `no_matching_reviews`, and are never charged as Review events.

Download the dataset as JSON, CSV, or Excel from Storage, or read it directly through the Apify API.

### 💰 Pricing

Pay only for results and optional enhancements you actually receive. No subscription and no minimum spend.

| Event | Price | When |
|---|---|---|
| Actor Start | **$0.05 per 1,000 starts** | per Actor start, with one event per GB of memory and a minimum of one |
| Review | **$1.50 per 1,000 rows** | per product review or site review delivered |
| Add-on: Advanced filter | **$0.50 per 1,000 rows** | per delivered review kept by one or more paid filters |
| Add-on: Review translated | **$2.00 per 1,000 rows** | per delivered review for which translated text is returned |
| Add-on: Media downloaded | **$1.00 per 1,000 files** | per review photo or video archived successfully |

Rating filters, all six Junip sorts, public locale values, source photo and video URLs, standard output fields, and status rows are free.

### 💡 Good to know

- **Store URLs return site reviews only.** Submit product URLs when you need product reviews. A store can have many product reviews but few or no public site reviews.
- **Product groups follow the public widget.** Junip can show reviews attached to related products in one product review group. The `productId`, `productHandle`, `productTitle`, and `productUrl` fields identify the exact product attached to each returned row.
- **Dedup is automatic.** Locale prefixes, `www` variants, trailing slashes, query strings, hash fragments, and case variations of the same product handle are fetched once.
- **Not on Junip?** If a store runs Okendo, Loox, Yotpo, or Judge.me instead, the uncharged status row names the detected provider and links to the matching sibling Actor.
- **Status rows are never charged.** Unsupported providers, unavailable products, empty filtered results, and rejected URLs return a stable `error` value that explains the outcome.
- **Field coverage matches the public source.** If Junip did not publish a requested value, the field returns `null`. Fields turned off in the Output fields section are omitted.
- **Site-review media is not exposed by this source.** Product reviews can include customer photo and video URLs and optional archived files.
- **Media limits are strict.** Up to 10 files per product review and 3 MB per file. Only verified photo or video responses are stored successfully and billed.
- **Runs are independent.** No cross-run history is kept. Schedule runs and compare `reviewId` values on your side to track new reviews.
- Files and datasets live in your Apify storage. Retention depends on the Apify plan of the account running the Actor.

### ❓ FAQ

**Do I need a Junip or Shopify account?**
No. The Actor reads only publicly published storefront and review data.

**What if a store does not use Junip?**
You get one uncharged status row that explains the outcome. When the Actor recognizes a supported sibling widget, it names and links the matching Okendo, Loox, Yotpo, or Judge.me scraper.

**Why did a store URL return fewer reviews than expected?**
Store URLs return Junip site reviews, not the store's product-review catalog. Submit individual product URLs to collect product reviews.

**Why does a product URL return reviews for related products?**
Some merchants combine related products in one Junip review group. The Actor matches the public widget and includes the exact product identity on every review row.

**What if no reviews match?**
You get an uncharged status row with `error: "no_matching_reviews"`. It may mean the target has no public reviews or that the selected filters removed every review.

**Why are some fields null?**
Not every public review includes every value. For example, older reviews may not include a locale, survey answers, an edit time, or a recommendation response. `null` means the field was requested but Junip did not expose a value.

**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 choose CSV, Excel, JSON, or another supported format.

**Which stores work?**
Shopify stores with a publicly reachable Junip review widget. Product URLs need a readable product review group; store URLs need publicly published site reviews.

**How long are my results stored?**
Results live in your Apify dataset and downloaded media lives in the run's key-value store. Retention depends on your Apify plan.

### 🔗 Other tools you might like

- [Shopify Okendo Reviews Scraper API](https://apify.com/lurkapi/shopify-okendo-reviews-scraper-api): reviews and product data from Shopify stores using Okendo.
- [Shopify Loox Reviews Scraper API](https://apify.com/lurkapi/shopify-loox-reviews-scraper-api): reviews and product data from Shopify stores using Loox.
- [Shopify Yotpo Reviews Scraper API](https://apify.com/lurkapi/shopify-yotpo-reviews-scraper-api): reviews and product data from Shopify stores using Yotpo.
- [Shopify Judge.me Reviews Scraper API](https://apify.com/lurkapi/shopify-judge-me-reviews-scraper-api): reviews and product data from Shopify stores using Judge.me.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with Shopify's and Junip'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, junip reviews, shopify review scraper, junip review scraper, product reviews export, shopify site reviews, review dataset, review sentiment data, verified buyer reviews, ecommerce review data

# Actor input Schema

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

Paste a Shopify store URL to get every public Junip site review. Paste a specific product URL to get the product-group reviews shown by its Junip widget. Both types can be mixed in the same run.

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

Cap on review rows returned for each input URL. A store URL returns up to this many site reviews; a product URL returns up to this many product-group 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`):

Junip's built-in orders (newest, oldest, rating, helpful, and featured first) are free.

## `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 Junip 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 the store has publicly replied to.

## `wouldRecommendOnly` (type: `boolean`):

Only keep reviews whose author said they would recommend the product or store.

## `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).

## `minContentLength` (type: `integer`):

Only keep reviews whose written body has at least this many characters. Leave at zero to disable this filter.

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

Only keep reviews in these public Junip locales. Use ISO codes such as en, es, or pt-BR. A base code such as en also matches regional tags such as en-US.

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

Translate the review title and body into your chosen target language. Charged only when translated text is returned for a delivered review.

## `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 product 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 hexclad.com.

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

Full canonical URL of the store's home page.

## `outputStoreName` (type: `boolean`):

Public store display name.

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

The URL slug Shopify uses in product paths on product-review rows.

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

Public product name attached to each product review.

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

Canonical link to the product attached to each product review.

## `outputProductRatingAverage` (type: `boolean`):

Junip's product-level average rating attached to each product review.

## `outputProductRatingCount` (type: `boolean`):

Total number of Junip reviews in the attached product's public review group.

## `outputProductRatingDistribution` (type: `boolean`):

Five numeric columns containing the product's 1 through 5 star review counts.

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

Public review title.

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

Timestamp when the review was posted.

## `outputUpdatedAt` (type: `boolean`):

Latest review update timestamp.

## `outputEditedAt` (type: `boolean`):

Public edit timestamp when present.

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

Public reviewer display name exactly as provided.

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

Junip's verified-purchase flag on each review.

## `outputWouldRecommend` (type: `boolean`):

Whether the reviewer recommends the target.

## `outputFeatured` (type: `boolean`):

Whether the merchant featured this review.

## `outputPurchasedVariant` (type: `boolean`):

Public target or variant title attached to the review.

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

Public reply the store posted to the review.

## `outputReplyAuthor` (type: `boolean`):

Public display name attached to the merchant response.

## `outputLanguage` (type: `boolean`):

Public locale code attached to the review.

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

Source URLs for customer photos and videos, plus archived file references when requested.

## `outputSurveyAnswers` (type: `boolean`):

Public survey responses formatted as readable strings.

## `outputJunipDetails` (type: `boolean`):

Identity confirmation, source, provider, reward, and vote fields.

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

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

## Actor input object example

```json
{
  "startUrls": [
    "https://hexclad.com/products/damascus-steel-starter-knife-set-2-pc-espresso"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "newest",
  "verifiedOnly": false,
  "onlyWithMedia": false,
  "onlyWithPhotos": false,
  "onlyWithVideos": false,
  "merchantReplyOnly": false,
  "wouldRecommendOnly": false,
  "minContentLength": 0,
  "filterLanguages": [],
  "translateReviews": false,
  "translationTarget": "en",
  "downloadMedia": false,
  "outputStoreDomain": true,
  "outputStoreUrl": true,
  "outputStoreName": true,
  "outputProductHandle": true,
  "outputProductTitle": true,
  "outputProductUrl": true,
  "outputProductRatingAverage": true,
  "outputProductRatingCount": true,
  "outputProductRatingDistribution": true,
  "outputReviewTitle": true,
  "outputPublishedAt": true,
  "outputUpdatedAt": true,
  "outputEditedAt": true,
  "outputReviewerName": true,
  "outputVerifiedBuyer": true,
  "outputWouldRecommend": true,
  "outputFeatured": true,
  "outputPurchasedVariant": true,
  "outputReply": true,
  "outputReplyAuthor": true,
  "outputLanguage": true,
  "outputMediaUrls": true,
  "outputSurveyAnswers": true,
  "outputJunipDetails": true,
  "outputInputUrl": true
}
```

# Actor output Schema

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

Compact mixed view of all product reviews, site reviews, and explanatory rows.

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

One row per product-group review from product URL inputs, including the product attached to each review.

## `storeReviews` (type: `string`):

One row per public site review from store URL inputs.

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

Public locales, survey answers, translations, media URLs, and archived file references.

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

Review photos and videos that this run archived to the default key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://hexclad.com/products/damascus-steel-starter-knife-set-2-pc-espresso"
    ],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "newest",
    "filterLanguages": [],
    "translationTarget": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/shopify-junip-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://hexclad.com/products/damascus-steel-starter-knife-set-2-pc-espresso"],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "newest",
    "filterLanguages": [],
    "translationTarget": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/shopify-junip-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://hexclad.com/products/damascus-steel-starter-knife-set-2-pc-espresso"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "newest",
  "filterLanguages": [],
  "translationTarget": "en"
}' |
apify call lurkapi/shopify-junip-reviews-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Junip Reviews Scraper API",
        "description": "Scrape Junip product reviews from Shopify product URLs and site reviews from store URLs.",
        "version": "0.0",
        "x-build-id": "5l3DyS3HFQSbXvbCV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~shopify-junip-reviews-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-shopify-junip-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-junip-reviews-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-shopify-junip-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-junip-reviews-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-shopify-junip-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 every public Junip site review. Paste a specific product URL to get the product-group reviews shown by its Junip widget. 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 review rows returned for each input URL. A store URL returns up to this many site reviews; a product URL returns up to this many product-group 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": [
                            "newest",
                            "oldest",
                            "highest_rating",
                            "lowest_rating",
                            "most_helpful",
                            "featured_first"
                        ],
                        "type": "string",
                        "description": "Junip's built-in orders (newest, oldest, rating, helpful, and featured first) are free.",
                        "default": "newest"
                    },
                    "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 Junip 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 the store has publicly replied to.",
                        "default": false
                    },
                    "wouldRecommendOnly": {
                        "title": "Only recommended reviews ($)",
                        "type": "boolean",
                        "description": "Only keep reviews whose author said they would recommend the product or store.",
                        "default": false
                    },
                    "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)."
                    },
                    "minContentLength": {
                        "title": "Minimum text length ($)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only keep reviews whose written body has at least this many characters. Leave at zero to disable this filter.",
                        "default": 0
                    },
                    "filterLanguages": {
                        "title": "Review languages ($)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Only keep reviews in these public Junip locales. Use ISO codes such as en, es, or pt-BR. A base code such as en also matches regional tags such as en-US.",
                        "items": {
                            "type": "string",
                            "maxLength": 16
                        }
                    },
                    "translateReviews": {
                        "title": "Translate reviews ($)",
                        "type": "boolean",
                        "description": "Translate the review title and body into your chosen target language. Charged only when translated text is returned for a delivered review.",
                        "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 product 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 hexclad.com.",
                        "default": true
                    },
                    "outputStoreUrl": {
                        "title": "Store URL",
                        "type": "boolean",
                        "description": "Full canonical URL of the store's home page.",
                        "default": true
                    },
                    "outputStoreName": {
                        "title": "Store name",
                        "type": "boolean",
                        "description": "Public store display name.",
                        "default": true
                    },
                    "outputProductHandle": {
                        "title": "Product handle",
                        "type": "boolean",
                        "description": "The URL slug Shopify uses in product paths on product-review rows.",
                        "default": true
                    },
                    "outputProductTitle": {
                        "title": "Product title",
                        "type": "boolean",
                        "description": "Public product name attached to each product review.",
                        "default": true
                    },
                    "outputProductUrl": {
                        "title": "Product URL",
                        "type": "boolean",
                        "description": "Canonical link to the product attached to each product review.",
                        "default": true
                    },
                    "outputProductRatingAverage": {
                        "title": "Product rating average",
                        "type": "boolean",
                        "description": "Junip's product-level average rating attached to each product review.",
                        "default": true
                    },
                    "outputProductRatingCount": {
                        "title": "Product rating count",
                        "type": "boolean",
                        "description": "Total number of Junip reviews in the attached product's public review group.",
                        "default": true
                    },
                    "outputProductRatingDistribution": {
                        "title": "Product rating distribution",
                        "type": "boolean",
                        "description": "Five numeric columns containing the product's 1 through 5 star review counts.",
                        "default": true
                    },
                    "outputReviewTitle": {
                        "title": "Review title",
                        "type": "boolean",
                        "description": "Public review title.",
                        "default": true
                    },
                    "outputPublishedAt": {
                        "title": "Review date",
                        "type": "boolean",
                        "description": "Timestamp when the review was posted.",
                        "default": true
                    },
                    "outputUpdatedAt": {
                        "title": "Updated date",
                        "type": "boolean",
                        "description": "Latest review update timestamp.",
                        "default": true
                    },
                    "outputEditedAt": {
                        "title": "Edited date",
                        "type": "boolean",
                        "description": "Public edit timestamp when present.",
                        "default": true
                    },
                    "outputReviewerName": {
                        "title": "Reviewer name",
                        "type": "boolean",
                        "description": "Public reviewer display name exactly as provided.",
                        "default": true
                    },
                    "outputVerifiedBuyer": {
                        "title": "Verified buyer flag",
                        "type": "boolean",
                        "description": "Junip's verified-purchase flag on each review.",
                        "default": true
                    },
                    "outputWouldRecommend": {
                        "title": "Would recommend",
                        "type": "boolean",
                        "description": "Whether the reviewer recommends the target.",
                        "default": true
                    },
                    "outputFeatured": {
                        "title": "Featured review",
                        "type": "boolean",
                        "description": "Whether the merchant featured this review.",
                        "default": true
                    },
                    "outputPurchasedVariant": {
                        "title": "Purchased variant",
                        "type": "boolean",
                        "description": "Public target or variant title attached to the review.",
                        "default": true
                    },
                    "outputReply": {
                        "title": "Merchant reply",
                        "type": "boolean",
                        "description": "Public reply the store posted to the review.",
                        "default": true
                    },
                    "outputReplyAuthor": {
                        "title": "Reply author",
                        "type": "boolean",
                        "description": "Public display name attached to the merchant response.",
                        "default": true
                    },
                    "outputLanguage": {
                        "title": "Review language",
                        "type": "boolean",
                        "description": "Public locale code attached to the review.",
                        "default": true
                    },
                    "outputMediaUrls": {
                        "title": "Media URLs and downloads",
                        "type": "boolean",
                        "description": "Source URLs for customer photos and videos, plus archived file references when requested.",
                        "default": true
                    },
                    "outputSurveyAnswers": {
                        "title": "Survey answers",
                        "type": "boolean",
                        "description": "Public survey responses formatted as readable strings.",
                        "default": true
                    },
                    "outputJunipDetails": {
                        "title": "Additional review details",
                        "type": "boolean",
                        "description": "Identity confirmation, source, provider, reward, and vote fields.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
