# Shopify Air / AG Product Reviews (Avada) Scraper API (`lurkapi/shopify-air-ag-product-reviews-scraper-api`) Actor

Scrape Air Product Reviews (AG Product Reviews App & UGC) from any Shopify store or product URL. Every review in a store from one link.

- **URL**: https://apify.com/lurkapi/shopify-air-ag-product-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 Air / AG Product Reviews (Avada) Scraper API

Pull every public Air Product Reviews review from any Shopify store into one clean spreadsheet. Sweep every 1-star review from a competitor, export the full review history for one SKU, or collect the whole storefront from a single link. 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 reviews across the entire store, with product details on every row. Good for catalog-wide sentiment analysis, competitor monitoring, and complete review exports.
2. **Product URL** returns reviews for that exact product, with its average rating, review count, and five-star rating histogram on every row. Good for quote pulls, launch 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 newest, oldest, highest rating, lowest rating, or pictures first.
- **Paid keyword search**: pull only reviews mentioning a phrase like "refund", "sizing", or "gift".
- **Paid verified, media, and reply filters**: verified buyers only, photos only, videos only, either type of media, or reviews the store publicly replied to.
- **Paid date, content, country, and language filters**: narrow to a date window, require written text or rating-only entries, set a minimum text length, or select reviewer countries and review languages.
- **Paid language detection**: tag delivered reviews with a detected language.
- **Free translation**: request the translation published by the store's review app in your chosen language.
- **Paid media archiving**: save review photos and direct video files to your run storage.

Duplicate URLs collapse automatically, and the same review reached through both a store URL and one of its product URLs is delivered only once. Explanatory status rows are always free.

Good for: Shopify founders watching reviews week over week, CMOs auditing a competitor, agencies reporting across client stores, 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. Duplicates are cleaned up automatically.

- **Store URL**: `https://l5graphix.com/`
- **Product URL**: `https://l5graphix.com/products/custom-legends-car-graphics`

Minimum input, run as-is:

```json
{
  "startUrls": [
    "https://l5graphix.com/products/custom-legends-car-graphics"
  ],
  "maxResultsPerUrl": 50
}
````

`maxResultsPerUrl` is the only limit you need. It defaults to 50 and can be set as high as 50,000. The cap is applied independently to every store or product URL.

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

Free filters and sorts sent to Air Product Reviews:

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

Paid add-ons are billed only when they actually deliver a result:

- **Keyword search**: only reviews whose title or text contains your phrase.
- **Verified only**: only reviews marked 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.
- **Date range**: only reviews posted between two dates.
- **Written vs rating-only**: keep only reviews with text, or only star ratings without text.
- **Minimum review length**: remove one-word and other short reviews.
- **Country filter**: only reviewers from the countries you select.
- **Language filter**: only reviews in the languages you select; language detection turns on automatically.
- **Language detection**: add `detectedLanguage` when detection succeeds.
- **Media archiving**: save up to 10 photos or direct videos per review, with a 3 MB limit per file.

Translation uses the store's own review app and does not add an add-on charge. If the store has no translation for a review, `translatedText` is `null`.

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

Click **Start**. Reviews stream into the Output tab as they are collected. The output includes the complete dataset and three ready-made views:

- **Overview**: the most useful review and product columns for every row.
- **Reviews**: review text, rating, reviewer, reply, product, and media fields.
- **Language & Media**: detected languages, translated text, source media, and archived files.

Every row starts with `status`. `Success` means the row is real review data. Anything else is a plain-English explanation, while `error` contains a stable code such as `air_not_detected` or `no_matching_reviews`. Explanatory rows are never charged.

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

### 💰 Pricing

Pay only for review results and successful add-ons. No subscription and no minimum.

| Event | Price | When |
|---|---:|---|
| Actor Start | **$1.00 per 1,000 starts** | one event per GB of memory per run, with a minimum of one |
| Review | **$1.50 per 1,000 rows** | one public review is delivered |
| Add-on: Advanced filter | **$0.50 per 1,000 rows** | a delivered review is kept by one or more paid filters; charged once per row, not once per filter |
| Add-on: Language detected | **$0.50 per 1,000 rows** | language detection succeeds on a delivered review |
| Add-on: Media downloaded | **$1.00 per 1,000 files** | one verified review photo or direct video is archived successfully |

Rating filters, all five sort choices, translations supplied by the store, original media source URLs, and explanatory status rows do not add an add-on charge.

### 💡 Good to know

- **One store link can collect the whole review feed.** You do not need to discover every product URL first.
- **Product runs include rating context.** Average rating, total review count, and 1-star through 5-star counts are included when the public product summary is available.
- **Dedup is automatic.** URL variants are normalized, and the same review ID from the same store is delivered once per run, even when targets overlap.
- **Only approved public reviews are returned.** Reviews that are internal, rejected, or not publicly approved are excluded.
- **Not on Air Product Reviews?** When a supported sibling widget is detected, the status row names the matching tool to run instead.
- **Status rows are never charged.** Unsupported providers, unavailable storefronts, empty results, and rejected URLs return a stable `error` value with a plain-English explanation.
- **Field coverage matches the source.** A requested field the storefront did not publish is `null`; a field toggled off in the 📦 Output fields section is omitted.
- **Imported text is cleaned.** Common reversible encoding artifacts and spreadsheet carriage-return markers are repaired without rewriting normal review text.
- **Public product links stay public.** Internal `myshopify.com` product links are replaced with the storefront domain when that mapping is available.
- **Media limits are strict.** Up to 10 files per review and 3 MB per file. Only verified photo or direct video responses are archived; the source URLs remain in the review row either way.
- **Runs are independent.** No cross-run history is kept. Schedule runs and compare `reviewId` across datasets to track new reviews.
- Files and datasets live in your Apify storage. Retention depends on your Apify plan.

### ❓ FAQ

**Do I need an Air Product Reviews or Shopify account?**

No. Only publicly published storefront and review data is read.

**What if a store does not use Air Product Reviews?**

You get one uncharged status row that explains it. When the Actor detects Okendo, Judge.me, Loox, or Yotpo, the message links to the matching sibling scraper.

**Why did I get fewer reviews than the storefront shows?**

The Actor returns public approved reviews made available by the store. `maxResultsPerUrl`, overlapping-target deduplication, and any filters you selected can reduce the final count.

**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.

**Why is `videoUrls` usually empty?**

Most stores using this review app collect customer photos more often than direct videos. The field is populated when the public review data provides a video URL.

**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 Excel, CSV, JSON, or another supported format. CSV exports can be imported directly into Google Sheets.

**Which stores work?**

Public Shopify stores whose review widget is powered by Air Product Reviews, also known as AG Product Reviews App & UGC.

**How long are my results stored?**

Results live in your Apify dataset and archived files live 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): same job for stores running Okendo.
- [Shopify Judge.me Reviews Scraper API](https://apify.com/lurkapi/shopify-judge-me-reviews-scraper-api): same job for stores running Judge.me.
- [Shopify Loox Reviews Scraper API](https://apify.com/lurkapi/shopify-loox-reviews-scraper-api): same job for stores running Loox.
- [Shopify Yotpo Reviews Scraper API](https://apify.com/lurkapi/shopify-yotpo-reviews-scraper-api): same job for stores running Yotpo.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with Shopify's and Air Reviews' 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, air product reviews, ag product reviews, air reviews scraper, shopify review scraper, product reviews export, shopify product ratings, review dataset, review sentiment data, ecommerce review data

# Actor input Schema

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

Paste a Shopify store URL to collect every public review in that store, with product details on each row. Paste a specific product URL to collect that product's reviews plus its star breakdown. Both types can be mixed in the same run.

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

Cap on rows returned for each input URL.

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

All five orders are served directly by the store's review app and 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 the store's review app marks as verified.

## `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 a customer video. Most stores collect photos rather than videos.

## `merchantReplyOnly` (type: `boolean`):

Only keep reviews where the store replied publicly. Private replies are never returned.

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

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

Only keep reviews whose text is at least this many characters. Useful for filtering out one-word reviews.

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

Only keep reviews from these countries. Use two-letter codes such as US, GB, DE.

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

Only keep reviews in these languages. Use ISO codes such as en, eng, es, or pt-BR. The store's review app does not publish a language, so this filter turns on local language detection automatically.

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

Adds a detectedLanguage field. Charged only when detection succeeds on a delivered row.

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

Adds a translated version of each review. Translations come from the store's own review app, so this is free.

## `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 your-store.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 reviewed product.

## `outputProductImageUrl` (type: `boolean`):

URL of the product image shown next to the review.

## `outputProductIds` (type: `boolean`):

Every product this review is attached to, when a store links one review to several products.

## `outputAverageRating` (type: `boolean`):

Product average rating. Present on product URL runs.

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

Total public reviews on the product. Present on product URL runs.

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

Review counts per star level as five separate columns. Present on product URL runs.

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

Review headline, when the store collects one.

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

When the review was posted.

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

Public reviewer display name.

## `outputReviewerCountry` (type: `boolean`):

Two-letter country code shown on the review.

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

Whether the review is marked as verified.

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

Helpful and not-helpful vote counts.

## `outputHighlightFlags` (type: `boolean`):

Whether the store pinned or featured this review.

## `outputReviewSource` (type: `boolean`):

Whether the review was written on the store or imported from another marketplace.

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

Public reply the merchant posted, and when it was posted.

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

Product variant the reviewer bought, when the store records it.

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

Source URLs for customer photos and videos on each review.

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

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

## Actor input object example

```json
{
  "startUrls": [
    "https://femallay.com/products/cleansing-suppositories-for-vaginal-health-hygiene"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "newest",
  "verifiedOnly": false,
  "onlyWithMedia": false,
  "onlyWithPhotos": false,
  "onlyWithVideos": false,
  "merchantReplyOnly": false,
  "reviewContent": "all",
  "minContentLength": 0,
  "filterCountries": [],
  "filterLanguages": [],
  "detectLanguage": false,
  "translateReviews": false,
  "translationTarget": "en",
  "downloadMedia": false,
  "outputStoreDomain": true,
  "outputStoreUrl": true,
  "outputProductHandle": true,
  "outputProductTitle": true,
  "outputProductUrl": true,
  "outputProductImageUrl": true,
  "outputProductIds": true,
  "outputAverageRating": true,
  "outputReviewCount": true,
  "outputRatingHistogram": true,
  "outputReviewTitle": true,
  "outputPublishedAt": true,
  "outputReviewerName": true,
  "outputReviewerCountry": true,
  "outputVerifiedBuyer": true,
  "outputVotes": true,
  "outputHighlightFlags": true,
  "outputReviewSource": true,
  "outputReply": true,
  "outputPurchasedVariant": true,
  "outputMediaUrls": true,
  "outputInputUrl": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

All review and explanatory rows.

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

Every row with the most useful columns.

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

One row per review with text, rating, reviewer, reply, and media links.

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

Review language, translation, and archived media fields.

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

Photos and short videos that this run archived to your Apify 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://femallay.com/products/cleansing-suppositories-for-vaginal-health-hygiene"
    ],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "newest",
    "filterCountries": [],
    "filterLanguages": [],
    "translationTarget": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/shopify-air-ag-product-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://femallay.com/products/cleansing-suppositories-for-vaginal-health-hygiene"],
    "maxResultsPerUrl": 50,
    "filterRatings": [],
    "sortBy": "newest",
    "filterCountries": [],
    "filterLanguages": [],
    "translationTarget": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/shopify-air-ag-product-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://femallay.com/products/cleansing-suppositories-for-vaginal-health-hygiene"
  ],
  "maxResultsPerUrl": 50,
  "filterRatings": [],
  "sortBy": "newest",
  "filterCountries": [],
  "filterLanguages": [],
  "translationTarget": "en"
}' |
apify call lurkapi/shopify-air-ag-product-reviews-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Air / AG Product Reviews (Avada) Scraper API",
        "description": "Scrape Air Product Reviews (AG Product Reviews App & UGC) from any Shopify store or product URL. Every review in a store from one link.",
        "version": "0.0",
        "x-build-id": "5PPw3auj9Ff8FZ4Cq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~shopify-air-ag-product-reviews-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-shopify-air-ag-product-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-air-ag-product-reviews-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-shopify-air-ag-product-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-air-ag-product-reviews-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-shopify-air-ag-product-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 collect every public review in that store, with product details on each row. Paste a specific product URL to collect that product's reviews plus its star breakdown. 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.",
                        "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",
                            "pictures_first"
                        ],
                        "type": "string",
                        "description": "All five orders are served directly by the store's review app and 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 the store's review app marks as verified.",
                        "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 a customer video. Most stores collect photos rather than videos.",
                        "default": false
                    },
                    "merchantReplyOnly": {
                        "title": "Only reviews with store replies ($)",
                        "type": "boolean",
                        "description": "Only keep reviews where the store replied publicly. Private replies are never returned.",
                        "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)."
                    },
                    "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"
                    },
                    "minContentLength": {
                        "title": "Minimum review length ($)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Only keep reviews whose text is at least this many characters. Useful for filtering out one-word reviews.",
                        "default": 0
                    },
                    "filterCountries": {
                        "title": "Reviewer countries ($)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Only keep reviews from these countries. Use two-letter codes such as US, GB, DE.",
                        "items": {
                            "type": "string",
                            "maxLength": 2
                        }
                    },
                    "filterLanguages": {
                        "title": "Review languages ($)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Only keep reviews in these languages. Use ISO codes such as en, eng, es, or pt-BR. The store's review app does not publish a language, so this filter turns on local language detection automatically.",
                        "items": {
                            "type": "string",
                            "maxLength": 16
                        }
                    },
                    "detectLanguage": {
                        "title": "Detect review language ($)",
                        "type": "boolean",
                        "description": "Adds a detectedLanguage field. Charged only when detection succeeds on a delivered row.",
                        "default": false
                    },
                    "translateReviews": {
                        "title": "Translate reviews",
                        "type": "boolean",
                        "description": "Adds a translated version of each review. Translations come from the store's own review app, so this is free.",
                        "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 your-store.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 reviewed product.",
                        "default": true
                    },
                    "outputProductImageUrl": {
                        "title": "Product image",
                        "type": "boolean",
                        "description": "URL of the product image shown next to the review.",
                        "default": true
                    },
                    "outputProductIds": {
                        "title": "All product IDs",
                        "type": "boolean",
                        "description": "Every product this review is attached to, when a store links one review to several products.",
                        "default": true
                    },
                    "outputAverageRating": {
                        "title": "Average rating",
                        "type": "boolean",
                        "description": "Product average rating. Present on product URL runs.",
                        "default": true
                    },
                    "outputReviewCount": {
                        "title": "Review count",
                        "type": "boolean",
                        "description": "Total public reviews on the product. Present on product URL runs.",
                        "default": true
                    },
                    "outputRatingHistogram": {
                        "title": "Rating histogram",
                        "type": "boolean",
                        "description": "Review counts per star level as five separate columns. Present on product URL runs.",
                        "default": true
                    },
                    "outputReviewTitle": {
                        "title": "Review title",
                        "type": "boolean",
                        "description": "Review headline, when the store collects one.",
                        "default": true
                    },
                    "outputPublishedAt": {
                        "title": "Review date",
                        "type": "boolean",
                        "description": "When the review was posted.",
                        "default": true
                    },
                    "outputReviewerName": {
                        "title": "Reviewer name",
                        "type": "boolean",
                        "description": "Public reviewer display name.",
                        "default": true
                    },
                    "outputReviewerCountry": {
                        "title": "Reviewer country",
                        "type": "boolean",
                        "description": "Two-letter country code shown on the review.",
                        "default": true
                    },
                    "outputVerifiedBuyer": {
                        "title": "Verified buyer flag",
                        "type": "boolean",
                        "description": "Whether the review is marked as verified.",
                        "default": true
                    },
                    "outputVotes": {
                        "title": "Helpful votes",
                        "type": "boolean",
                        "description": "Helpful and not-helpful vote counts.",
                        "default": true
                    },
                    "outputHighlightFlags": {
                        "title": "Pinned and featured flags",
                        "type": "boolean",
                        "description": "Whether the store pinned or featured this review.",
                        "default": true
                    },
                    "outputReviewSource": {
                        "title": "Review source",
                        "type": "boolean",
                        "description": "Whether the review was written on the store or imported from another marketplace.",
                        "default": true
                    },
                    "outputReply": {
                        "title": "Merchant reply",
                        "type": "boolean",
                        "description": "Public reply the merchant posted, and when it was posted.",
                        "default": true
                    },
                    "outputPurchasedVariant": {
                        "title": "Purchased variant",
                        "type": "boolean",
                        "description": "Product variant the reviewer bought, when the store records it.",
                        "default": true
                    },
                    "outputMediaUrls": {
                        "title": "Media URLs",
                        "type": "boolean",
                        "description": "Source URLs for customer photos and videos on each review.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
