Chrome Web Store Reviews Scraper

Extract public Chrome Web Store extension reviews from extension IDs or URLs, with review text, ratings, dates and extension metadata. Use the dataset for product-feedback research, competitor comparisons and support triage, then export it as CSV, Excel or JSON.

Optional review fields can be missing. The review-order setting applies only when additional reviews are requested. A small sample may retain the page's existing order.

Quick start

1. Paste an extension ID or its Chrome Web Store URL.
2. Set a small per-extension limit, then start the Actor.
3. Open the dataset and export the fields you need.

{
  "extensionIds": ["cjpalhdlnbpafiamejdnhcphjbkeiagm"],
  "maxReviewsPerExtension": 25,
  "sort": "newest",
  "language": "en-US",
  "proxyConfiguration": { "useApifyProxy": false }
}

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

Ready-to-run examples

Choose a public example to see its settings before starting a run:

• Scrape reviews from a Chrome Web Store extension URL
• Find the most helpful uBlock Origin reviews
• Scrape the newest uBlock Origin reviews

What you get

One row per saved public extension review, with extension and review identity, text and any available rating, date or developer response. Optional values can be null. Page-level extension rating summaries provide context rather than a count or score for only the reviews returned by this run.

Who is it for?

• Extension publishers: collect public complaints and feature requests for product planning.
• Product researchers: compare feedback across competing extensions.
• Support teams: review low-rated feedback in a spreadsheet or downstream analysis tool.

The Actor supplies review data, not sentiment scores, automatic alerts or a built-in history of changes.

How you can use the data

• Prepare an extension-feedback triage sheet. Supply a known extension ID, such as the example in Quick start, and a small per-extension cap. Export extensionId, reviewId, reviewText, rating and available developerResponse, then prioritize low-rated feedback in your own spreadsheet.
• Compare two known extensions. Collect bounded samples for each and retain the extension identity beside every review. Missing developer replies, votes or versions remain unknown rather than zero, and the samples are not guaranteed to represent all feedback.
• Compare your own review snapshots. Keep extensionId, reviewId, sourceUrl and scrapedAt with the export, then review new or changed text in your own workflow. The Actor does not create sentiment scores, automatic alerts or a history of changes.
• Review ordering before drawing conclusions. The initial batch can keep its source order, while additional reviews use the requested ordering when available. A small export should not be described as the newest or most helpful reviews by default.

Input settings

Provide at least one valid entry in startUrls or extensionIds. Both can be combined. Duplicate extension IDs are processed once.

Setting	JSON key	Purpose
Chrome Web Store URLs	startUrls	Extension detail or reviews URLs.
Extension IDs	extensionIds	Raw 32-character extension IDs.
Maximum reviews per extension	maxReviewsPerExtension	Cap of 1–5,000. Input schema default 20.
Review order	sort	newest or helpful for additional reviews. Initial batch order can remain unchanged.
Language	language	Request language, default en-US. Not a guaranteed review-language filter.
Country code	country	Accepted but currently has no effect.
Proxy configuration	proxyConfiguration	Direct, managed or customer proxy settings. See field help for defaults and charges.

For URL-based input:

{
  "startUrls": [{ "url": "https://chromewebstore.google.com/detail/cjpalhdlnbpafiamejdnhcphjbkeiagm/reviews" }],
  "maxReviewsPerExtension": 25,
  "proxyConfiguration": { "useApifyProxy": false }
}

Output data

Each dataset row represents a public review. This abbreviated, shape-only example uses placeholders, not a claimed live review:

{
  "extensionId": "cjpalhdlnbpafiamejdnhcphjbkeiagm",
  "extensionName": null,
  "reviewId": "<public-review-id>",
  "rating": 4,
  "reviewText": "<public review text>",
  "reviewerName": null,
  "publishedAt": null,
  "developerResponse": null,
  "helpfulCount": null
}

Fields	Meaning
extensionId, extensionUrl, extensionName	Extension identity and public name.
extensionAverageRating, extensionRatingCount	Page-level rating summary when available.
reviewId, rating, reviewText	Review identifier, stars and public text.
reviewerName, reviewerProfileUrl	Public display name and avatar/image URL when exposed. Not a verified profile page.
reviewDate, publishedAt, updatedAt	ISO timestamps when exposed. reviewDate aliases publishedAt.
developerResponse, developerResponseDate	Public developer reply and its date when available.
helpfulCount, version, language	Optional helpful votes, review-associated version and language.
sourceUrl, scrapedAt	Input/generated reviews URL and the run's collection timestamp.

Optional fields are nullable. Missing replies, versions or helpful counts do not imply that the corresponding value is zero.

Download your results

Open your run's dataset, choose Export and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See Apify's download and export guide for the available formats and field options.

Pricing

The start event (Run started) is charged once at startup, including runs that save no reviews. The review event (Review extracted) is charged for each public review saved to the dataset. A run with no saved reviews has no review-event charges.

Use a small maxReviewsPerExtension and a short extension list to bound requested output. See the live Pricing tab for current rates and subscription-tier discounts.

Tips for best results

• Use a known extension ID or public detail/reviews URL. Raw IDs are 32 characters, and duplicate IDs are processed once.
• Start with a small per-extension cap. Inspect review text and optional replies before connecting a triage workflow.
• Check ordering in the returned sample. The requested sort affects additional reviews and does not reorder the initial batch.
• Treat language as a request preference. It is not a guaranteed review-language filter, and the country setting currently has no effect.
• Report unexpected empty results with a run ID. Include a reproducible public extension URL and expected versus actual output.

Limits and caveats

Only public Chrome Web Store review data is collected, without Google account login or private account data. The cap is a maximum rather than an exact count or a complete-review-history guarantee.

Unavailable pages or no extractable reviews can yield no rows, while other extensions may still provide useful records. A request or system failure can still fail the run. Unexpected empty output for a known public extension can indicate an extraction problem.

The initial page batch is not reordered. Additional reviews use the requested sort when available. Language is a request preference rather than a strict filter, and the accepted country field currently has no effect.

Site changes and optional-field availability affect returned data. Missing replies, versions or helpful counts are unknown rather than zero. The Actor does not perform sentiment analysis, send alerts or maintain a change history.

Automation and integrations

Save your settings for next time

Once you have an input that works for you, save it as an Apify task. This keeps your settings together so you can use them again without filling in the form from scratch.

Run on a schedule

Need fresh results regularly? You can schedule the Actor or a saved task to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

Send results to your other tools

Use n8n, Make or Zapier to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the Apify integration guides for your chosen tool.

For a custom connection, an Apify webhook can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its defaultDatasetId to fetch the results.

For setup instructions, see Apify's JavaScript client guide, Python client guide and Actor runs API reference.

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~chrome-web-store-reviews-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "extensionIds": [
    "cjpalhdlnbpafiamejdnhcphjbkeiagm"
  ],
  "maxReviewsPerExtension": 25,
  "sort": "newest",
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
JSON

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/chrome-web-store-reviews-scraper').call({
  "extensionIds": [
    "cjpalhdlnbpafiamejdnhcphjbkeiagm"
  ],
  "maxReviewsPerExtension": 25,
  "sort": "newest",
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/chrome-web-store-reviews-scraper').call(run_input={'extensionIds': ['cjpalhdlnbpafiamejdnhcphjbkeiagm'], 'maxReviewsPerExtension': 25, 'sort': 'newest', 'language': 'en-US', 'proxyConfiguration': {'useApifyProxy': False}})
print(client.dataset(run['defaultDatasetId']).list_items().items)

API and AI agents notes

The REST call starts an asynchronous run. Wait for completion, then retrieve items from its defaultDatasetId.

MCP and AI agents

You can ask your AI assistant to collect data with Chrome Web Store Reviews Scraper and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the Apify MCP server. MCP gives your assistant a way to find this scraper, run it and read the results. Follow the official setup and sign-in guide for your app.

Easier setup with an Apify plugin

If you use a supported coding assistant, the official Apify plugin can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

Use Apify AI in Console

Prefer to keep everything in Apify? Open Apify AI in Console and ask it to find Fetch Cat's Chrome Web Store Reviews Scraper. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

Choose your assistant

• Claude and Claude Code (Anthropic): Apify setup guide.
• ChatGPT and Codex (OpenAI): Apify setup guides.
• Grok Bot (xAI): Apify plugin guide.
• Gemini CLI (Google): MCP server setup guide. Use the server URL below with the HTTP configuration supported by Gemini CLI.

Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/chrome-web-store-reviews-scraper"
    }
  }
}

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

Use Apify's general server

Already connected to the general Apify MCP server at https://mcp.apify.com? You can use it to find this scraper without adding another server. Ask your assistant to use Chrome Web Store Reviews Scraper by Fetch Cat, or give it the identifier fetch_cat/chrome-web-store-reviews-scraper.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

Example requests

• “Use Fetch Cat’s Chrome Web Store Reviews Scraper to collect up to 5 public reviews for extension cjpalhdlnbpafiamejdnhcphjbkeiagm. Show review text, ratings, dates and any developer response, marking missing values.”
• “Collect at most 5 reviews per extension for these two known Chrome extension IDs. Keep each extension and review identifier with the text so I can compare product feedback in my own sheet.”
• “Retrieve a small sample of 5 reviews from this public Chrome Web Store reviews URL with English as the request language. Keep original review text and source links, without promising strict language filtering or newest-first order.”

Normal Apify charges apply. Check the live Pricing tab before asking your assistant to run a larger batch.

Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through x402. This experimental option lets an agent use Apify without a conventional account.

Apify AGI provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

Other ways for agents to pay

Apify also supports MPP for prepaid access through AGI and Skyfire for eligible Actors. If your agent already uses one of these, see the agentic payment guide to choose the right setup.

FAQ

Can I export Chrome Web Store reviews to CSV or Excel?

Yes. Open the run's dataset and use Apify's export controls, or retrieve JSON through the API.

Is this an official Chrome Web Store reviews API?

No. It is an independent public-data scraper, not a Google service. It needs no Google login.

Does changing the language or country filter reviews?

language sets the request language, not a strict review-language filter. country currently has no effect.

Can I compare several extensions?

Yes. Supply multiple IDs or URLs. Each extension has its own review cap. Filter and compare the saved rows in your analysis tool.

Can I monitor changes over time?

You can run the same input again and compare reviewId values across datasets. The Actor does not maintain a review history or send alerts itself.

Related Actors

• Chrome Web Store Scraper — extension listings and metadata.
• Google Maps Reviews Scraper — place reviews.
• Trustpilot Reviews Scraper — business feedback.
• Google Play Reviews Scraper — Android app reviews.
• Apple App Store Reviews Scraper — Apple app reviews.

Support and feedback

For custom additions or integrations, email hello@fetchcat.dev.

Found an error or have a feature request? Open an issue with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See Apify’s guide to sharing a run when reporting an issue. Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. Leave a review to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥