Shopify App Store Reviews Scraper

Scrape every review of any app on the Shopify App Store into clean, analysis-ready JSON. Give it one app or a hundred — https://apps.shopify.com/klaviyo-email-marketing or just the handle — and it paginates the entire review history and returns each review with its star rating, full text, merchant store name, country, ISO date, how long that merchant had been using the app, and the developer's public reply with its own date. No browser, no login, no API key: plain HTTP against the store's own pages, paced to stay inside the site's rate limit.

What you get from a single run:

• The whole review history, not just page one. Pagination is verified to page 904 of a 9,041-review app. Set maxReviewsPerApp above the app's total and you get all of it.
• The fields that make review data useful: rating, body, author (the merchant's store name), country, reviewedAt, usingAppFor / usingAppForDays (merchant tenure at the time of the review) and the developer's reply — the single best signal of how a competitor handles unhappy customers.
• App context on every row: appName, appDeveloper, appRating and appReviewCount, so a multi-app run is one flat table you can pivot immediately.
• Rating filter: pull only the 1- and 2-star reviews of five competitors in a couple of minutes.

Example output item (real review, unedited):

{
    "reviewId": "2208774",
    "reviewUrl": "https://apps.shopify.com/reviews/2208774",
    "appHandle": "klaviyo-email-marketing",
    "appUrl": "https://apps.shopify.com/klaviyo-email-marketing",
    "appName": "Klaviyo: Email Marketing & SMS",
    "appDeveloper": "Klaviyo",
    "appRating": 4.7,
    "appReviewCount": 2997,
    "rating": 1,
    "body": "\"Unable to checkout. Try again later.\" Can't upgrade my account because of Klaviyo's system issue. Can't contact support until I upgrade. Can't upgrade because of a system error. Complete and utter joke.",
    "author": "Colt's Woof",
    "country": "United States",
    "reviewedAt": "2026-05-18",
    "usingAppFor": "6 months",
    "usingAppForDays": 180,
    "developerReply": "We’re sorry to hear about the experience you had trying to upgrade your account. A senior member of our Support team has reached out directly. We appreciate your patience while we work through this with you.",
    "developerReplyAt": "2026-05-22",
    "developerReplyBy": "Klaviyo",
    "scrapedAt": "2026-08-21T03:25:42.523Z"
}

How to scrape Shopify App Store reviews

1. Paste one or more apps into appUrls — a full listing URL, a /reviews URL, or a bare handle. All three work.
2. Set maxReviewsPerApp. The site serves 10 reviews per page, so 500 reviews = 50 requests. Set it higher than the app's review count to get every review.
3. Optionally pick a sortBy (newest or relevance) and a ratingFilter (any combination of 1–5 stars).
4. Press Start. Results land in the dataset and export as JSON, CSV or Excel, or sync to Google Sheets, webhooks, Zapier, Make or the Apify API.

Example input

{
    "appUrls": [
        "https://apps.shopify.com/klaviyo-email-marketing",
        "https://apps.shopify.com/omnisend",
        "privy"
    ],
    "maxReviewsPerApp": 3000,
    "sortBy": "newest",
    "ratingFilter": []
}

• appUrls — one entry per app. https://apps.shopify.com/<handle>, https://apps.shopify.com/<handle>/reviews, a locale URL like apps.shopify.com/es/<handle>, or the bare <handle>. Duplicates are collapsed.
• maxReviewsPerApp — cap per app, not per run. Three apps at 3,000 each can return 9,000 reviews in one dataset.
• sortBy — newest (strict newest-to-oldest; the right choice for monitoring and for resuming) or relevance (the site's own default ordering). These are the only two orders the Shopify App Store offers.
• ratingFilter — keep only these star ratings, e.g. ["1","2"]. Empty = all.
• proxyConfiguration — optional. Plain requests work; enable Apify proxies only if your runs start hitting 403s.

Output fields

Field	Type	Description
reviewId	string	Shopify's own review ID, stable across runs — use it to dedup and diff
reviewUrl	string	Permalink to the single review (apps.shopify.com/reviews/<id>)
appHandle	string	App handle, e.g. klaviyo-email-marketing
appUrl	string	App listing URL
appName	string | null	App name as listed
appDeveloper	string | null	Developer / partner name
appRating	number | null	The app's overall average rating at scrape time
appReviewCount	number | null	The app's total review count at scrape time
rating	number	This review's star rating, 1–5
body	string | null	Full review text, paragraphs preserved. null when the merchant left stars only — see Performance & limits
author	string | null	The reviewing merchant's store name
country	string | null	Merchant's country, e.g. United States, Denmark
reviewedAt	string | null	Review date, ISO YYYY-MM-DD
usingAppFor	string | null	How long the merchant had used the app, e.g. About 4 years, 19 days
usingAppForDays	number | null	The same tenure as approximate days, ready to sort and bucket
developerReply	string | null	The developer's public reply, full text
developerReplyAt	string | null	Reply date, ISO YYYY-MM-DD
developerReplyBy	string | null	Who replied, as shown ("Klaviyo replied")
scrapedAt	string	ISO 8601 UTC timestamp of this run

A run summary (apps, filters, pages fetched per app, totals reported by the site, throttling absorbed, errors) is stored in the run's key-value store under SUMMARY.

There is no review title. The Shopify App Store review form takes a star rating and a body — nothing else. Unlike the Apple App Store or Google Play, there is no headline to extract, so the Actor does not invent one.

What can you do with Shopify App Store review data?

• Competitor teardown: pull every 1- and 2-star review of the apps in your category and read what merchants actually complain about — pricing, support latency, a specific broken feature. It is the cheapest product-research there is.
• Positioning and copy: 5-star reviews say, in merchants' own words, which benefit they care about. Feed them to an LLM and get your landing-page headline.
• Support benchmarking: developerReply + developerReplyAt − reviewedAt gives every competitor's public response rate and response time.
• Churn and tenure signals: usingAppForDays on negative reviews shows when merchants give up — during onboarding, or after a year on a plan.
• Market monitoring: schedule with sortBy: "newest" and a modest cap, diff on reviewId, and get an alert the moment a competitor's rating starts sliding.
• Geo analysis: country across thousands of reviews shows which markets an app actually serves — 78 countries in a single 2,845-review sample.

Integrations

Every Apify dataset exports to CSV, Excel, JSON, XML or HTML with one click, or syncs to Google Sheets, and the Actor plugs into Zapier, Make, webhooks, MCP and the Apify API:

# Python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("fabrikit/shopify-app-store-reviews-scraper").call(run_input={
    "appUrls": ["https://apps.shopify.com/klaviyo-email-marketing"],
    "maxReviewsPerApp": 3000,
    "sortBy": "newest",
})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["rating"], review["country"], "—", review["body"])

// Node.js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('fabrikit/shopify-app-store-reviews-scraper').call({
    appUrls: ['https://apps.shopify.com/omnisend', 'privy'],
    maxReviewsPerApp: 500,
    ratingFilter: ['1', '2'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'negative reviews');

Performance & limits

• 10 reviews per request — the page size is fixed by the site. 1,000 reviews = 100 requests.
• The Actor paces itself at ~1.25 requests/second. The Shopify App Store sits behind Cloudflare and starts returning HTTP 429 at roughly 100 requests per minute (measured, not guessed). Running under that ceiling, a 2,845-review run finished with zero throttled requests. Expect roughly 700–750 reviews per minute.
• Throttling never becomes a hole in your data. A 429 triggers a backoff, the whole run slows down permanently, and any page that still failed is retried in a second pass at the end. Pages that fail even then are listed in SUMMARY.errors.
• Pagination is not capped: page 904 of a 9,041-review app returns real reviews.
• body is null for star-only reviews. Shopify lets a merchant submit a rating with no text, and many do — verified at the source, including on each review's own permalink. Coverage is app-dependent: ~67% of Klaviyo's reviews have text, ~84% of TrackingMore's, ~51% of Loox's. This is the source data, not a parsing gap. Filter on body != null if you only want prose.
• usingAppFor is missing on ~0.3% of reviews — the site itself omits the line for some merchants.
• Reviews are deduplicated by reviewId within a run.
• An app handle that does not exist is logged and skipped; the rest of the run continues.

Tips for best results

• To get everything, set maxReviewsPerApp above the app's review count (visible on its listing page, and returned as appReviewCount on every item). There is no penalty for overshooting — the Actor stops at the last real page.
• For monitoring, use sortBy: "newest" with a small cap (say 100) on a daily schedule and dedup on reviewId. You pay for what you fetch, so this costs cents per month.
• For competitor research, filter first: ratingFilter: ["1","2"] on an app with 3,000 reviews usually means ~200 reviews and ~20 requests, not 300.
• Don't chase body coverage — a 5-star review with no text is still a signal (it moves the average); a 1-star review with 300 words is the one you want to read. Sort by rating ascending and body length descending.
• usingAppForDays is approximate by construction — the site prints "about 4 years", not a date. Use it for bucketing (under 30 days / under a year / long-term), not for exact arithmetic.
• Many apps at once is cheaper than many runs: one run, several appUrls, one dataset, one start fee.

Pricing — US$1.00 per 1,000 reviews

This Actor uses Apify's pay-per-event model and charges per review delivered (event review-result, US$0.001 per review = US$1.00 per 1,000 reviews) plus a tiny run-start fee (US$0.00005), on top of standard Apify platform usage. No subscription, no rental fee. You only pay for reviews actually pushed to your dataset — a run that finds nothing costs essentially nothing.

FAQ

Is there a Shopify App Store reviews API? No public one. Shopify does not expose app reviews through the Admin or Partner API. This Actor reads the same public review pages a shopper sees, over plain HTTP, and normalizes them into one schema.

Can I get ALL reviews of a big app? Yes. Pagination is verified deep into the list (page 904 of 905 on a 9,041-review app). Set maxReviewsPerApp high enough and budget roughly a minute per 700 reviews.

Why is body sometimes empty? Because the merchant left a star rating without writing anything. Verified directly on the individual review permalinks — there is no hidden text the Actor is missing. See Performance & limits for typical coverage.

Do reviews have titles? No. The Shopify App Store review form has only a star rating and a body. Any scraper that returns a "title" for a Shopify app review is making it up.

Are the dates real dates? Yes: reviewedAt and developerReplyAt are ISO YYYY-MM-DD, converted from the site's "August 20, 2026" display format. scrapedAt is full UTC ISO 8601.

Does it get blocked? Not at a sane pace. The site rate-limits at roughly 100 requests/minute; the Actor stays under that, backs off on 429 and retries. No proxy is needed by default, and proxyConfiguration is there if you ever want one.

Can I scrape several apps in one run? Yes — put as many as you like into appUrls. Each is paginated separately up to maxReviewsPerApp, and every item carries appHandle/appName, so one dataset covers a whole competitive set.

Is it legal to scrape app reviews? The Actor reads only reviews the Shopify App Store publishes publicly, at a polite rate, and collects no private personal data — the author is a public store name that merchants chose to attach to a public review. How you use the data remains your own compliance decision.

Support

Found a bug, or need a field the store shows but the Actor doesn't return yet? Open an issue in the Issues tab — issues are typically answered within 24 hours.

More scrapers by Fabrikit

• Trabajando.cl Jobs Scraper — Chile Job Listings — the Chilean job board in one flat table, with salary, comuna and GPS coordinates.
• ATS Jobs Scraper — Greenhouse, Lever, Ashby & SmartRecruiters — job postings from any company on the four biggest ATS platforms.
• App Reviews Scraper — App Store & Google Play — mobile app reviews from both stores in one normalized dataset.

Technical details

• Data source: the public apps.shopify.com/<handle>/reviews pages, which are server-rendered — the review list is in the HTML, not fetched by JavaScript. No browser is started, so runs are fast and cheap.
• The "Show more" button on long reviews is client-side truncation only; the full text is always in the HTML, so nothing is truncated in the output.
• App name, developer, average rating and review count come from the page's JSON-LD SoftwareApplication block.
• Extraction is anchored on stable data-* attributes (data-merchant-review, data-review-share-link, data-merchant-review-reply) and ARIA labels, not on CSS classes — the site's Tailwind class names change constantly, and this Actor doesn't care.
• The dataset schema in .actor/actor.json is generated from the single field definition in src/fields.js (npm run schema) and re-verified against a real run by tools/check_schema.mjs, so a declared field can never drift from what the code actually produces.