Scrape Shopify App Store data with Python: a no-API guide

Retailers, researchers, and developers often need Shopify App Store data—ratings, pricing, and reviews—yet Shopify offers no public API. Instead, developers must either navigate brittle web layouts or rely on unofficial endpoints that break with each redesign. A reliable workaround is to use a hosted scraper that handles pagination, retries, and layout shifts behind the scenes.

In this guide, we’ll use a ready-made Apify actor to extract three types of data: app details, reviews (including store country and developer replies), and catalog discovery by keyword. The result is clean JSON you can pipe into a spreadsheet, database, or analysis tool—all using just a few lines of Python and a free Apify account.

Build a real-time data pipeline in five minutes

The process is split into three simple steps, each targeting a different use case:

• Fetch structured app details (rating, review count, pricing, developer) for one or more apps.
• Pull reviews with context like store country and developer responses to analyze sentiment.
• Discover apps across the entire catalog by keyword, useful for competitor analysis or market research.

All three tasks are handled by the Shopify App Store Scraper actor on Apify, which returns JSON without requiring login, API keys, or headless browser maintenance. You only need to call the actor and process the output.

Prerequisites and setup

To follow along, ensure you have Python 3.8+ and a free Apify account. Install the official client library using pip:

pip install apify-client

Next, retrieve your API token from Settings → Integrations in the Apify console. Store it securely in an environment variable to avoid committing it to source control:

export APIFY_TOKEN="apify_api_xxx"

With these prerequisites in place, you’re ready to run your first scrape.

Step 1: Fetch app details in bulk

The actor’s details mode returns structured app metadata from each app’s page. You pass a list of appHandles, which are the slugs found at the end of Shopify app URLs (for example, klaviyo-email-marketing from `).

Here’s a minimal script to pull details for two popular apps:

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run_input = {
    "mode": "details",
    "appHandles": [
        "klaviyo-email-marketing",
        "judgeme-product-reviews",
    ],
}

run = client.actor("freshactors/shopify-app-store-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']:40} ⭐ {item['rating']} ({item['reviewCount']} reviews) — {item['pricingSummary']}")

Each record includes fields like rating, review count, pricing summary, developer name, and icon URL. Because the scraper reads the page’s application/ld+json structured data, it remains stable even when Shopify updates its CSS or HTML structure.

Step 2: Pull reviews with store context

Switching to reviews mode lets you fetch customer reviews, including the reviewer’s country and any developer reply. You can limit volume with maxReviewsPerApp and sort by newest, highest, or lowest ratings.

The following snippet retrieves the 500 lowest-rated reviews for Klaviyo to surface common complaints:

run_input = {
    "mode": "reviews",
    "appHandles": ["klaviyo-email-marketing"],
    "maxReviewsPerApp": 500,
    "reviewsSort": "lowest_rating",
}

run = client.actor("freshactors/shopify-app-store-scraper").call(run_input=run_input)
reviews = list(client.dataset(run["defaultDatasetId"]).iterate_items())

print(f"Fetched {len(reviews)} reviews")

for r in reviews:
    if r["rating"] <= 2:
        print(f"[{r['rating']}★ {r['country']}] {r['storeName']}: {r['body'][:120]}")

Review records include the full text, store name, country, the store’s usage duration, and an optional developer reply. The actor’s retry logic prevents false negatives when a request temporarily fails, so you won’t see misleading zero-review counts.

Step 3: Discover apps by keyword across the catalog

The discover mode crawls Shopify’s official sitemap and returns full app details for every listing matching a keyword. This is ideal for competitor analysis or finding niche tools.

Below, we search for “email marketing” and cap the results at 50 apps:

import pandas as pd

run_input = {
    "mode": "discover",
    "query": "email marketing",
    "maxApps": 50,
}

run = client.actor("freshactors/shopify-app-store-scraper").call(run_input=run_input)
apps = list(client.dataset(run["defaultDatasetId"]).iterate_items())

# Build a ranked competitive landscape table
df = pd.DataFrame(apps)[["title", "developer", "rating", "reviewCount", "pricingSummary"]]
df = df.sort_values("reviewCount", ascending=False)
print(df.head(10).to_string(index=False))

You can leave query empty to list every app in the catalog, which is useful for broad market analysis. The resulting dataset includes title, developer, rating, review count, and pricing—ready for export or further analysis.

Pro tip: run asynchronously for large jobs

Using .call() waits for completion, which is fine for small tasks. For larger pulls, start the task in the background and poll later:

started = client.actor("freshactors/shopify-app-store-scraper").start(run_input=run_input)
print("Run id:", started["id"])

You can also export datasets directly from the Apify console to CSV, Excel, or JSON, or schedule recurring runs with Apify Schedules to keep your data fresh.

Cost and scalability

The actor uses a pay-per-result pricing model: app details cost about $0.002 each, discovery entries $0.001, and reviews $0.0001. For example, pulling details for 100 apps costs roughly $0.20, while 20,000 reviews would total around $2.00. This makes it practical to run daily scrapes without breaking the budget.

Whether you’re benchmarking competitors, auditing app performance, or building research datasets, a hosted scraper removes the maintenance burden and keeps your pipelines running smoothly—no API key required.

As Shopify’s layout evolves, the scraper continues to work because it relies on stable structured data rather than fragile selectors. That reliability is the real value: focus on insights, not infrastructure.