# Shopify App Store Scraper (`davidts/shopify-app-store-scraper`) Actor Extract apps and reviews from the Shopify App Store: name, developer, rating, review count, pricing plans, free trial, categories, Built for Shopify badge, launch date, languages, integrations. Browse by category, developer or app URL; optionally every review with text, date and developer reply. - **URL**: https://apify.com/davidts/shopify-app-store-scraper.md - **Developed by:** [David Tsitsakishvili](https://apify.com/davidts) (community) - **Categories:** E-commerce, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.00 / 1,000 apps 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/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Shopify App Store Scraper **Shopify App Store Scraper** exports **Shopify apps and app reviews** from the Shopify App Store (apps.shopify.com) for **competitor research** and market analysis: name, developer, rating and review count, **pricing plans** with free plans and trials, categories and feature tags, the **Built for Shopify** badge, launch date, languages, integrations ("Works with"), icon, description and screenshots. Browse a **whole category**, a **developer's page** or a **collection**, or scrape **individual apps**, and optionally collect **every review** (rating, date, text, country, time using the app, developer reply) as its own record. Export to JSON, CSV or Excel. No login, no browser: the Store is server-rendered HTML, which the Actor reads politely (3 requests at a time, short pauses between them) through Apify proxies. ### What can you do with it - **Track competitor apps**: pricing plans, trial lengths, ratings, review velocity and Built for Shopify badges of the apps you compete with, on a weekly schedule. - **Size a category before you build**: every app of a category with ratings, review counts, prices and launch dates in one spreadsheet, to spot crowded and under-served niches. - **Mine app reviews**: what merchants praise and complain about, 1-star reviews of a competitor, how fast developers reply - ready for a spreadsheet or an LLM. - **Benchmark pricing**: compare plans, free plans, trials and starting prices across a whole category. - **Shortlist apps for clients**: agencies and consultants get every app of a category with ratings and feature tags instead of opening hundreds of Store pages. - **Study developer portfolios**: all apps of a developer (`/partners/` pages) with launch dates and ratings. #### Who it is for - **App developers and product teams** tracking competitors: pricing changes, new plans, trial lengths, rating trends, review velocity, which apps carry the Built for Shopify badge, which integrations they list. - **Agencies and consultants** building app shortlists for merchants. - **Analysts and investors** studying the ecosystem: launch dates, developer portfolios, category sizes, rating distributions. - **Marketers and support teams** mining reviews. - **Developers** who want the data as JSON/CSV or through an API without maintaining a scraper. Pricing starts at **$2 per 1,000 records** (apps or reviews); see *Pricing* below. ### How to use 1. Open [Shopify App Store Scraper](https://apify.com/davidts/shopify-app-store-scraper) and click **Try for free** (or **Start**). 2. Enter **categories** (e.g. `marketing-and-conversion-marketing-email-marketing`), **app URLs** or a developer page, set **Maximum number of apps**, and switch on **Include reviews** if you want them. 3. Click **Start** and download apps and reviews as CSV, Excel or JSON from the **Output** tab (the **Overview** and **Reviews** views split them), or fetch them through the API. #### Sample output (selected columns) | name | developer.name | rating | reviewCount | pricing.fromPriceUsd | pricing.freeTrialDays | builtForShopify | launchedAt | | --- | --- | --- | --- | --- | --- | --- | --- | | Loox ‑ Product Reviews App | Loox | 4.9 | 9999 | 12.99 | 14 | true | 2015-10-16 | The full app and review records are shown under *Output* below. ### Input Give at least one of `categories`, `appUrls` or `startUrls`; they can be combined. | Field | Type | Default | Description | | --- | --- | --- | --- | | `categories` | array | - | Category slugs (the last part of `apps.shopify.com/categories/`): the 7 top-level categories `marketing-and-conversion`, `store-design`, `orders-and-shipping`, `selling-products`, `finding-products`, `sales-channels`, `store-management`, or a sub-category such as `marketing-and-conversion-marketing-email-marketing`, `store-design-storefronts-page-builder`, `orders-and-shipping-order-tracking`. A top-level category is followed into all of its sub-categories; a sub-category is read completely through its "View all apps" listing (24 apps per page). Every slug is listed on [apps.shopify.com/sitemap](https://apps.shopify.com/sitemap). | | `appUrls` | array | - | Individual apps: Store URLs (`https://apps.shopify.com/klaviyo-email-marketing`) or handles (`klaviyo-email-marketing`). A reviews URL (`.../klaviyo-email-marketing/reviews`) switches reviews on for that app. | | `startUrls` | array | - | Any Store page: category pages (also `/categories//all?page=3`), developer pages (`/partners/`), collection pages (`/collections/`), app pages, or `https://apps.shopify.com/sitemap` to crawl **every** category. | | `maxApps` | integer | `200` | Stop after this many apps (across everything). `0` = no limit. | | `includeReviews` | boolean | `false` | Also collect the reviews of every app, one record per review. | | `maxReviewsPerApp` | integer | `50` | Reviews per app when `includeReviews` is on (10 per Store page). `0` = all. | | `sortBy` | select | `newest` | Order of the reviews: `newest` (date, newest first; many of these are star-only ratings without text) or `relevance` (the Store's "Most relevant", written reviews first). It decides which reviews you get when `maxReviewsPerApp` cuts them off. Apps keep the Store's own listing order (the Store offers no sort for apps). | | `includeReviewerStoreName` | boolean | `false` | Add `reviewerStoreName` (the Shopify store that wrote the review) to review records. | | `proxyConfiguration` | object | Apify proxy | Apify datacenter proxies by default. Switch to **residential** proxies if the log shows HTTP 429 on the `/all` listing pages (see *Limitations*). | Keyword search (`/search?q=`) is **not** offered: the Store's `robots.txt` disallows it for crawlers. Categories and developer pages cover the same ground. #### Example 1: the top apps of a category with their listings (the default prefill) ```json { "categories": ["marketing-and-conversion"], "maxApps": 20 } ``` #### Example 2: every email-marketing app with its newest 100 reviews ```json { "categories": ["marketing-and-conversion-marketing-email-marketing"], "maxApps": 0, "includeReviews": true, "maxReviewsPerApp": 100, "sortBy": "newest" } ``` #### Example 3: competitor watch - a handful of apps and a developer's whole portfolio ```json { "appUrls": ["klaviyo-email-marketing", "omnisend", "https://apps.shopify.com/mailchimp"], "startUrls": ["https://apps.shopify.com/partners/klaviyo"], "includeReviews": true, "maxReviewsPerApp": 20 } ``` #### Example 4: the whole Store ```json { "startUrls": ["https://apps.shopify.com/sitemap"], "maxApps": 0 } ``` (Several thousand apps; set a maximum cost per run in the run options if you want a cap.) ### Output One dataset item per app (`type: "app"`): ```json { "type": "app", "url": "https://apps.shopify.com/loox", "slug": "loox", "name": "Loox ‑ Product Reviews App", "listingStatus": "listed", "developer": { "name": "Loox", "url": "https://apps.shopify.com/partners/loox", "website": "https://loox.app/" }, "rating": 4.9, "reviewCount": 9999, "ratingDistribution": { "5": 9422, "4": 345, "3": 48, "2": 37, "1": 147 }, "pricing": { "summary": "Free plan available. Free trial available.", "hasFreePlan": true, "freeToInstall": false, "hasFreeTrial": true, "freeTrialDays": 14, "fromPriceUsd": 12.99, "fromPricePeriod": "month", "plans": [ { "name": "Beginner", "priceText": "Free", "amount": 0, "currency": null, "period": null, "trialText": null, "trialDays": null, "additionalCharges": null, "features": ["Review request emails & reminders", "Up to 500 orders"] }, { "name": "Scale", "priceText": "$12.99/month", "amount": 12.99, "currency": "USD", "period": "month", "trialText": "14-day free trial", "trialDays": 14, "additionalCharges": "or $124.70/year and save 20%", "features": ["Google, Meta, TikTok syndication", "Integrations, API access, and webhooks"] } ] }, "categories": [ { "name": "Product reviews", "slug": "marketing-and-conversion-social-trust-product-reviews", "url": "https://apps.shopify.com/categories/marketing-and-conversion-social-trust-product-reviews" } ], "features": ["Automated requests", "Photo reviews", "Refer a friend"], "builtForShopify": true, "launchedAt": "2015-10-16", "languages": ["English", "French", "Spanish", "German", "Portuguese (Brazil)", "Japanese"], "worksWith": ["Checkout", "Shopify Flow", "Klaviyo"], "iconUrl": "https://cdn.shopify.com/app-store/listing_images/252ae7c55fa0e8a35df7f6ff3c8c1596/icon/CPLp1Kb0lu8CEAE=.jpg", "tagline": "Convert more with visual product reviews, superpowered by AI", "description": "Loox is the all-in-one social proof app: collect photo & video reviews automatically ...", "highlights": ["Collect photo & video reviews with automated review request emails", "Display reviews in 17+ widgets that match your brand"], "screenshotUrls": ["https://cdn.shopify.com/app-store/listing_images/252ae7c55fa0e8a35df7f6ff3c8c1596/desktop_screenshot/CKj9jO3k7ZQDEAE=.png"], "scrapedAt": "2026-10-29T12:00:00.000Z" } ``` And, with `includeReviews`, one item per review (`type: "review"`): ```json { "type": "review", "appSlug": "loox", "appUrl": "https://apps.shopify.com/loox", "reviewId": "2398974", "reviewUrl": "https://apps.shopify.com/reviews/2398974", "rating": 1, "date": "2026-10-17", "text": "They will repeatedly over charge you with sneaky changes to their policy. Use Judge.me instead.", "country": "United States", "timeUsingApp": "About 2 years", "hasDeveloperReply": true, "developerReply": "Hey,\nThanks for taking the time to leave feedback.\n\nWe keep our pricing clear and transparent.", "developerReplyDate": "2026-10-18", "scrapedAt": "2026-10-29T12:00:00.000Z" } ``` | Field | Meaning | | --- | --- | | `url`, `slug`, `name` | The app page and its handle (`slug` is what you pass to `appUrls`). | | `listingStatus` | `listed`, or `unlisted` when the app's page still exists but the listing was removed from the Store (then rating, pricing and categories are null/empty). | | `developer` | Name, Store page (`/partners/`, lists all their apps) and website of the developer. | | `rating`, `reviewCount`, `ratingDistribution` | Average rating (one decimal), number of reviews, and reviews per star level. | | `pricing.summary` | The Store's one-line summary: `Free plan available`, `Free to install`, `From $9.99/month`, ... | | `pricing.hasFreePlan` / `freeToInstall` / `hasFreeTrial` / `freeTrialDays` | Derived from the summary and the plan cards. `freeToInstall` means usage-based charges may apply; `freeTrialDays` is null when the page only says "Free trial available". | | `pricing.fromPriceUsd`, `fromPricePeriod` | Lowest paid plan (monthly plans first), null for free-only apps. | | `pricing.plans` | Every plan card: name, price as printed and parsed, trial note, additional-charges note, feature bullets. | | `categories`, `features` | Categories the app is listed in (slug usable as `categories` input) and the Store's feature tags of the listing. | | `builtForShopify` | True when the listing carries the Built for Shopify badge. | | `launchedAt` | Launch date on the Store (`YYYY-MM-DD`). | | `languages`, `worksWith` | Supported languages and the integrations listed under "Works with". | | `iconUrl`, `tagline`, `description`, `highlights`, `screenshotUrls` | The listing's media and texts. | | `appSlug`, `appUrl` (reviews) | Which app the review belongs to (join key to the app items). | | `rating`, `date`, `text`, `country`, `timeUsingApp` (reviews) | The review: 1-5 stars, date, text (paragraphs separated by blank lines), the reviewer's country and how long they had used the app. | | `hasDeveloperReply`, `developerReply`, `developerReplyDate` (reviews) | The developer's public reply, when there is one. | | `reviewerStoreName` (reviews) | Only with `includeReviewerStoreName`. | | `scrapedAt` | When the item was collected. | The **Overview** tab of a run shows one row per app (name, developer, rating, reviews, pricing, badge, launch date, link); the **Reviews** tab shows the review rows. Export everything as JSON, CSV or Excel, or read it through the API like any Apify dataset. ### Pricing This Actor uses Apify's **pay-per-event** model, so you only pay for what you get: - **$0.002 per record** saved to the dataset - an app listing, or one review when `includeReviews` is on (the Store's event title is "App"; reviews are the same dataset-item event), and - **$0.005 per run start**. 1,000 apps therefore cost **$2.005**; 1,000 apps with 50 reviews each (51,000 records) cost **$102.005**. The exact prices are shown on the Pricing tab of this page. Platform usage (compute, proxies) is covered by these prices and is **not** billed separately. Set a maximum cost per run in the run options if you want a hard cap; everything saved until then stays in the dataset. ### How it works 1. The input is turned into Store pages: category landing pages, `/categories//all` listings (24 apps per page), developer and collection pages, the HTML sitemap, and app pages. Search URLs are refused (robots.txt). 2. Listing pages are parsed for app cards; every new app is queued until `maxApps` is reached. Pagination follows the Store's own "Next" links; a page that repeats the previous one stops the listing. Top-level category pages are followed into their sub-categories, sub-category pages into their complete listing. 3. Every app page becomes one item: the JSON-LD block (name, description, rating) is preferred where it exists, the rest is read from the page (hero, pricing cards, details, developer section, review metrics). 4. With `includeReviews`, the app's review pages (`//reviews?sort_by=...&page=N`, 10 per page) are read until `maxReviewsPerApp` or the last page. Politeness: at most 3 requests in flight, 300-800 ms between requests, exponential backoff with new proxy sessions on HTTP 429/5xx (5 retries). A run with 20 apps takes about half a minute; 30 apps with 12 reviews each (93 pages) took two minutes on the platform, so 200 apps with 50 reviews each (about 1,200 pages) take roughly 25 minutes. The log ends with a summary: listing pages, apps queued and saved, review pages, reviews saved, and any pages that failed. ### Limitations - **Rate limiting.** The Store throttles per IP address with `429 Too Many Requests`; the complete listings (`/categories//all`) are hit first, app and review pages now and then. The Actor retries with backoff and fresh proxy sessions (which usually clears it within one or two retries), keeps the apps it already found (category landing pages list 12-40 recommended apps and were never blocked) and reports pages that stayed blocked in the log and the run summary. If a complete category listing keeps failing with datacenter proxies, use **residential** proxies in `proxyConfiguration`. - **Store order, no search.** Apps come in the Store's own listing order (there is no sort for apps) and keyword search is disallowed by robots.txt. Reviews can be sorted by date or relevance. - **Unlisted apps** (removed from the Store) still have a page; they are saved with `listingStatus: "unlisted"` and mostly null fields so you can tell they are gone. - **Prices** are read as printed on the English Store page (`$15/month`, `Free to install`); usage-based charges are only reflected in `additionalCharges` texts. `freeTrialDays` is null when the page does not state the number of days. - **Review counts** on cards and the "9.4K" style numbers in the rating distribution are rounded by the Store; `reviewCount` on app items is exact. - **Star-only reviews** (a rating without text) are common among the newest reviews - on the pages checked on 2026-10-29 between 4 and 7 of the 10 newest reviews of popular apps had no text. They come with `text: null` and usually no `timeUsingApp`. For review texts, prefer `sortBy: "relevance"`, which puts written reviews first. - The Store changes its markup now and then; the Actor is tested daily (see the Actor's health status) and fixed promptly when a change breaks a field. ### Legal, privacy and robots.txt The Actor reads only public pages of apps.shopify.com and respects the Store's `robots.txt` (checked 2026-10-29): `/search` (`*q=*`), `/internal/`, `/services/`, `/login/`, `/partner/login` and `/api/collect` are disallowed for crawlers and are never requested; category, app, review, developer, collection and sitemap pages are allowed. Personal data: the Actor collects the data merchants and developers publish on the Store about **apps and companies**. It never collects the developer's support e-mail or postal address (both are on the page and deliberately skipped). Reviews are written by Shopify **stores** (businesses); their store name is left out by default (`includeReviewerStoreName`), the review text is public. Make sure your use of the data complies with Shopify's terms of service and the laws that apply to you. ### Integrations - **Make, Zapier, n8n and other automation tools**: add the Apify integration (the official "Apify" app/node), choose *Run an Actor* with this Actor and your input, and use *Get dataset items* (or the "Actor run finished" trigger) to pass the records on - for example to a Google Sheet of competitor prices or a Slack alert on new 1-star reviews. Each tool also accepts Apify webhooks: Console -> Actor -> Integrations -> Webhooks, event `Run succeeded`. - **AI agents (MCP)**: Apify's MCP server (`https://mcp.apify.com`, or the `@apify/actors-mcp-server` package) exposes this Actor as a tool to Claude, ChatGPT, Cursor and other MCP clients: the agent calls `shopify-app-store-scraper` with an input such as `{"categories": ["marketing-and-conversion"], "maxApps": 20}` and reads the dataset items back. - **API and SDKs**: `POST https://api.apify.com/v2/acts/davidts~shopify-app-store-scraper/run-sync-get-dataset-items` with the input as JSON body returns the records directly; the Apify client libraries for JavaScript and Python wrap the same call. - **Schedules**: Console -> Schedules lets you run the Actor daily or weekly with a saved input (for example your competitor list with `includeReviews` and `maxReviewsPerApp: 20`) and combine it with a webhook or integration to get only what changed. ### Troubleshooting | Log message | What it means | | --- | --- | | `Invalid input: Give at least one of startUrls, categories or appUrls` | Nothing to scrape was given. | | `Skipping start URL ".../search?q=..." ... robots.txt` | Keyword search is disallowed; use a category or developer page instead. | | `Listing page ... does not exist (HTTP 404)` | Wrong category slug or URL; check apps.shopify.com/sitemap. Note that only sub-categories have an `/all` listing. | | `App "..." does not exist on the Store (HTTP 404)` | Wrong handle, or the app was removed completely. | | `... rate-limited the requests (HTTP 429 Too Many Requests) even after 5 retries` | The Store throttled the page from the proxy's IP range; the apps found so far are kept. Try again later or switch to residential proxies. | | `... repeats the previous page; stopping the pagination here` | The Store served the same page twice (end of the listing); nothing is lost. | | `Nothing was saved: ...` | Every page failed or nothing matched; the message lists the reasons. | | `maxApps is 0 (no limit)` / `maxReviewsPerApp is 0 (no limit)` | A reminder that everything found will be saved and charged. | | `The maximum cost per run set for this run was reached` | Raise the limit in the run options to get more. | ### FAQ **How much does it cost per 1,000 apps or reviews?** **$2** per 1,000 records ($0.002 each; an app listing and a review are one record each) plus $0.005 per run. Platform usage, including proxies, is included. 200 apps with 50 reviews each is 10,200 records, about $20.40. You can cap the cost of any run in the run options. **Is it legal to scrape the Shopify App Store? What about robots.txt and GDPR?** The Actor reads only public Store pages that `robots.txt` allows (it never uses the disallowed `/search`), does not log in and skips developers' support e-mails and postal addresses. Reviews are written by stores (businesses) and the reviewing store's name is off by default. You remain responsible for complying with Shopify's terms and the laws that apply to you (for example GDPR if you process personal data in the EU). This is not legal advice. **Can I export the apps and reviews to CSV, Excel or Google Sheets?** Yes. Every run's dataset downloads as CSV, Excel, JSON, XML or HTML from the Output tab. For Google Sheets, import the CSV, use the *Google Sheets Import & Export* Actor from the Apify Store or a Make/Zapier scenario, or point `=IMPORTDATA()` at the API URL of the last run's dataset (the URL contains your API token, so keep the sheet private). **Can I track competitors automatically every week?** Yes. Save an input with your competitors' `appUrls` (and `includeReviews` with a small `maxReviewsPerApp` and `sortBy: "newest"`) and create a weekly schedule in Apify Console. Compare runs in a sheet to see price, rating and review changes, or send new 1-star reviews to Slack with a webhook or Make/Zapier. **Can I use it from my code or an AI agent?** Yes. `POST https://api.apify.com/v2/acts/davidts~shopify-app-store-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN` with the input as JSON returns the records directly; the Apify JavaScript and Python clients and Apify's MCP server (for Claude, ChatGPT, Cursor and other agents) work too. See *Integrations*. **Can I search the Store by keyword?** No - the Store's `robots.txt` disallows its search pages for crawlers. Use categories, sub-categories, developer pages or app URLs instead; they cover the same apps. If this Actor saves you time, a short **review on its Store page** helps other people find it - thank you! Missing a field? Open an issue on the Issues tab and I will look at it. ### Changelog The full history is in the Actor's `CHANGELOG.md` (also shown in the Information tab in Apify Console). - **0.1** (2026-10) - first release: categories (with sub-categories and complete listings), developer and collection pages, sitemap crawl, app URLs, app listings with pricing plans, badges and metadata, reviews with developer replies, pay-per-event pricing. # Changelog This Actor's version history is a separate document: https://apify.com/davidts/shopify-app-store-scraper/changelog.md # Actor input Schema ## `categories` (type: `array`): Category slugs from apps.shopify.com/categories/, for example `marketing-and-conversion`, `store-design`, `orders-and-shipping`, `selling-products`, `finding-products`, `sales-channels`, `store-management`, or a sub-category such as `marketing-and-conversion-marketing-email-marketing` or `store-design-storefronts-page-builder`. A top-level category is followed into all of its sub-categories; a sub-category is read completely through its "View all apps" listing. The HTML sitemap at apps.shopify.com/sitemap lists every slug. ## `appUrls` (type: `array`): Individual apps to scrape: the Store URL (`https://apps.shopify.com/klaviyo-email-marketing`) or just the handle (`klaviyo-email-marketing`). A reviews URL (`.../klaviyo-email-marketing/reviews`) also works and switches reviews on for that app. Use this to track specific competitor apps. ## `startUrls` (type: `array`): Any apps.shopify.com page to start from: category pages (`/categories/` or `/categories//all?page=2`), developer pages (`/partners/`), collection pages (`/collections/`), app pages, or `https://apps.shopify.com/sitemap` to crawl every category. Search result URLs are refused (robots.txt). ## `maxApps` (type: `integer`): Stop after this many apps have been collected (across all categories, pages and app URLs). `0` means no limit: a whole top-level category can be a few thousand apps. For a first test, 10-20 is plenty. ## `includeReviews` (type: `boolean`): Also collect the reviews of every app (one dataset item per review with rating, date, text, country, time using the app and the developer's reply). Reviews are priced like apps, so 50 reviews for 200 apps are 10,000 extra results. Turn it on for review mining or sentiment analysis; leave it off for app listings, pricing and ratings only. ## `maxReviewsPerApp` (type: `integer`): How many reviews to collect per app when `includeReviews` is on (10 reviews per page on the Store). `0` means all reviews, which can be tens of thousands for popular apps. ## `sortBy` (type: `string`): Order in which the Store lists the reviews, which decides which reviews come first when `maxReviewsPerApp` cuts them off. `newest` includes many star-only ratings without text; `relevance` (the Store's default) puts written reviews first. Apps themselves keep the Store's own listing order (there is no sort option for apps on the Store). ## `includeReviewerStoreName` (type: `boolean`): Add `reviewerStoreName` (the name of the Shopify store that wrote the review) to every review item. Off by default: it is a business name, but you should only collect it when your use case needs it. ## `proxyConfiguration` (type: `object`): Proxies used for the requests to apps.shopify.com. Apify datacenter proxies (the default) are enough for app pages and reviews. The complete category listings (`/categories//all`) are the most protected pages of the Store: if the log reports HTTP 429 for them, switch to residential proxies. ## Actor input object example ```json { "categories": [ "marketing-and-conversion" ], "maxApps": 20, "includeReviews": false, "maxReviewsPerApp": 50, "sortBy": "newest", "includeReviewerStoreName": false, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): One item per app (type "app") and, with includeReviews, one item per review (type "review"); JSON, CSV or Excel via the format parameter # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "categories": [ "marketing-and-conversion" ], "maxApps": 20, "includeReviews": false, "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("davidts/shopify-app-store-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "categories": ["marketing-and-conversion"], "maxApps": 20, "includeReviews": False, "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("davidts/shopify-app-store-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "categories": [ "marketing-and-conversion" ], "maxApps": 20, "includeReviews": false, "proxyConfiguration": { "useApifyProxy": true } }' | apify call davidts/shopify-app-store-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,davidts/shopify-app-store-scraper" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/iw8carl19piCdYkqj/builds/BayzImgjxwBOkb7mc/openapi.json