# Chrome Web Store Scraper - Extensions, Users & Reviews (`s-r/chrome-web-store`) Actor

Chrome Web Store scraper for keyword searches, categories or extension IDs. Get one row per extension with developer, users, rating, version, size, permissions and contact details, plus public user reviews. For extension developers, SaaS marketers, security teams and market researchers.

- **URL**: https://apify.com/s-r/chrome-web-store.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Developer tools, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 extension listings

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

## Chrome Web Store Scraper - Extensions, Users and Reviews

This Chrome Web Store scraper collects extension listings and public user reviews in one
dataset. Search by keyword, browse an extension category, or supply extension IDs and store
URLs. Use it to compare competing extensions, track release changes, audit declared Chrome
extension permissions, find extension publishers, or understand what users report about an
extension.

Each extension is identified by its stable 32-letter store ID. Listing rows and review rows
share that ID, so you can join feedback to the corresponding software record. The dataset
includes a row type and a unique row identity, making it straightforward to separate the two
kinds of records when exporting to a spreadsheet or importing into a database.

### What does the Chrome Web Store scraper return?

- **Extension listings**: title, offered-by developer, developer website, category, rounded
  user count, average rating, rating count, version, last update, size, languages, featured
  flag, manifest version and declared permissions.
- **Publisher details**: support link, privacy policy link and, when the store shows them,
  the public business contact email, address, phone and legal company name.
- **Chrome Web Store reviews**: star rating, original text, public author name, publication
  time, helpful and unhelpful votes, review language, extension version and developer reply.

### How to scrape the Chrome Web Store

1. Enter search terms in `queries`, pick a `category`, or paste extension IDs or store URLs
   in `extensions`. You can combine them in one run.
2. Set `maxResults` for the number of extensions per search term or category.
3. Turn on `includeReviews` and set `maxReviews` when you also want user reviews.
4. Run the actor and download the dataset as JSON, CSV, Excel or through the API.

### Chrome Web Store Scraper input

Provide at least one of `queries`, `category`, or `extensions`. Search terms are an array of
strings. Direct extensions can be their IDs, current Chrome Web Store detail URLs, or older
Chrome store detail URLs. You may combine these entry points in a single run. Duplicate
extension IDs are collected once across the run; the first matching search supplies the
originating query and position.

`maxResults` limits listings per search term or category, with a default of 20 and a maximum
of 1000. Direct extension IDs are processed individually. A run accepts up to 20 search
terms and 1000 direct extensions. Category ordering (`categorySort`) supports popular
extensions, highest rated extensions, newly added extensions, and relevance, which makes it
easy to build your own list of top Chrome extensions per category. Keyword searches follow
the store's relevance ordering.

Turn on `includeReviews` to collect written reviews for each returned listing. `maxReviews`
defaults to 20 per extension and can be set up to 5000. Review ordering (`reviewSort`)
supports recent, relevant, lowest rating, and highest rating. `reviewRating` optionally
selects one exact star value from one to five. `reviewLanguage` defaults to `en`; use a
supported language code such as `de` when studying feedback in another language. There is no
all-languages setting: run each language separately when you need coverage across languages.
Listing text is collected in English.

For example, this input collects uBlock Origin Lite and its first three English reviews:

```json
{"extensions":["ddkjiahejlhfcafbddmgiahcphecmpfh"],"includeReviews":true,"maxReviews":3}
```

And this input collects the 50 most popular shopping extensions:

```json
{"category":"lifestyle/shopping","categorySort":"popular","maxResults":50}
```

### Output and exported fields

Rows with `record_type: listing` include the extension title, offered-by developer name,
developer website, category, rounded user count, average rating, rating count, version,
update timestamp, size, supported languages, and featured flag. Additional fields include
first publication time, icon and screenshot URLs, minimum Chrome version, declared
permissions, host permissions, optional permissions, support link, and privacy policy link.
The public business contact fields include email, address, phone, and legal company name
when the store supplies them. These fields support business research and identifying the
supplier of an extension.

Rows with `record_type: review` include the stable review ID, extension ID, individual star
rating, original text, public author display name, publication time, helpful and unhelpful
vote counts, language, and extension version when available. Developer replies are included
with their text, author, and publication time. Chrome reviews have no separate review
headline, so review rows omit `title`; `listing_title` contains the associated extension name.

#### Example output

A real listing row captured on 5 October 2026 for uBlock Origin Lite, shortened to the most
used fields (the full row also has the description, languages, screenshots and more):

```json
{
  "_type": "software_listing",
  "record_type": "listing",
  "platform": "chrome_web_store",
  "listing_id": "ddkjiahejlhfcafbddmgiahcphecmpfh",
  "url": "https://chromewebstore.google.com/detail/ddkjiahejlhfcafbddmgiahcphecmpfh",
  "title": "uBlock Origin Lite",
  "developer": "Raymond Hill (gorhill)",
  "category": "Privacy & Security",
  "rating": 4.502609173304037,
  "rating_count": 3641,
  "users": 21000000,
  "version": "2026.930.1227",
  "updated_at": "2026-09-30T14:36:39.000Z",
  "size": "9.2MiB",
  "manifest_version": 3,
  "featured": true,
  "permissions": ["activeTab", "alarms", "declarativeNetRequest", "offscreen", "scripting", "storage", "unlimitedStorage", "userScripts"],
  "host_permissions": ["<all_urls>"]
}
```

A real review row from the same run:

```json
{
  "_type": "software_review",
  "record_type": "review",
  "review_id": "c3b3f4f7-8826-4b7e-b2a2-34b673ac2de8",
  "listing_id": "ddkjiahejlhfcafbddmgiahcphecmpfh",
  "listing_title": "uBlock Origin Lite",
  "rating": 5,
  "text": "Great for people that are trapped inside google's ecosystem.\nDon't be like me, just use firefox and classic ublock.",
  "author_name": "Quim Bartolomé",
  "published_at": "2026-10-03T17:43:34.000Z",
  "app_version": "2026.930.1227",
  "likes": 0,
  "dislikes": 0,
  "language": "en"
}
```

These are dated observations, and future runs may return different values. The user count is
the rounded count displayed by the store, rather than an exact count of active installations.

Ratings and written reviews are different populations. `rating_count` counts ratings,
while `review_count` reflects written reviews after the requested language and star filters.
The latter is available when the review request was processed alongside its listing. Missing
source values remain null. Privacy category codes are returned as raw source codes because
their labels are not supplied with the record. The trader flag reports an explicit source
flag and does not establish a developer's legal status. Publisher flags may differ from the
badges displayed to an individual visitor.

### Use cases

- **Extension developers**: follow competitors' user counts, ratings, versions and release
  dates, and read their Chrome extension reviews for feature requests and complaints.
- **SaaS marketers**: find the extensions in your niche, measure their reach, and build lists
  of extension publishers with their website and public business contact.
- **Security teams**: audit Chrome extension permissions and host permissions for the
  extensions your organisation allows, and spot new versions that change them.
- **Market researchers**: run Chrome extension analytics across a whole category, compare
  ratings with user counts, and track how a category changes over time with scheduled runs.

### Compared with other options

The store has no public API for listing data or reviews, and copying records by hand stops
working beyond a few extensions. Open-source Chrome Web Store scraper libraries exist, but you
maintain them yourself when the store changes. Many other actors in the Apify Store cover
either extension details or reviews; this actor returns both in one dataset joined by
extension ID, with declared permissions and publisher contact fields on the listing row, and
continues large collections automatically.

### Pricing and free usage

The actor uses separate extension and review events. Each delivered listing counts as one
extension event, and each delivered review counts as one review event. Consult the actor's
current Pricing section for the published prices of these events. There is no start event,
and empty results do not create extension or review charges. A request for 20 reviews that
finds only eight written reviews delivers and counts those eight.

Users without a paid Apify plan receive at most ten dataset rows per run, including both
listings and reviews. The same delivery limit applies when the request asks for more rows.
Paid users can collect the requested volumes within the documented input limits. Run output
records indicate whether the free usage limit applied.

### Continuation and missing results

Large collections are continued automatically within the actor. Each extension and review
is deduplicated by its stable identity, including overlaps in category pages. The requested
volume is a maximum: removed extensions, unavailable records, and categories with fewer
matches can produce fewer rows. Warnings describe missing data and collection limitations.
The run output includes delivered counts and whether collection ended before all requested
work was completed. A listing remains available even when it has no matching written reviews.

### FAQ

#### Can I collect reviews without knowing a store URL?

Yes. Supply an extension ID in `extensions`, or discover extensions through a keyword or
category. Enable `includeReviews` and choose the review limit and language you need.

#### Does the actor download or install extensions?

It collects the public store record and declared manifest fields. It does not install the
extension. Permissions describe what the developer declared and do not prove how the
extension behaves while running.

#### Can I collect every review in every language?

Reviews are collected for the requested language and optional star filter. Run separate
languages and join the resulting rows by extension ID and review ID. The review limit
applies independently to each extension in each run.

#### Why can a requested extension be absent?

An extension may have been removed or become unavailable in the store. Such records produce
no listing row and no extension charge. Check the warnings in the run output for the IDs
that could not be collected.

#### Is there an official Chrome Web Store API for this data?

Google's Chrome Web Store API is meant for publishing and updating your own extensions. It
does not return other developers' listings, user counts or reviews; this actor collects that
public store data.

#### Can I monitor extensions over time?

Yes. Schedule the actor with the same extension IDs or category and compare runs by
`listing_id`: user count, rating, version and permissions show what changed between dates.

# Actor input Schema

## `queries` (type: `array`):

Search terms; at most 20. Results are deduplicated across the whole run.

## `category` (type: `string`):

Chrome Web Store extension category.

## `extensions` (type: `array`):

Extension IDs or current and legacy Chrome Web Store detail URLs; at most 1000.

## `categorySort` (type: `string`):

Category ordering. Search queries use the store relevance ordering.

## `maxResults` (type: `integer`):

Maximum unique listings per search term or category; direct extension IDs are processed individually.

## `includeReviews` (type: `boolean`):

Include public reviews for each returned extension.

## `maxReviews` (type: `integer`):

Maximum unique reviews per extension in the requested language.

## `reviewSort` (type: `string`):

Review ordering.

## `reviewRating` (type: `integer`):

Optional exact star filter, from 1 to 5.

## `reviewLanguage` (type: `string`):

Review language such as en, de or pt-BR. There is no all-languages mode. Listing text is fetched in English.

## `cursor` (type: `string`):

Opaque continuation returned by a previous request. Keep the original input unchanged.

## Actor input object example

```json
{
  "extensions": [
    "ddkjiahejlhfcafbddmgiahcphecmpfh"
  ],
  "categorySort": "popular",
  "maxResults": 20,
  "includeReviews": false,
  "maxReviews": 20,
  "reviewSort": "recent",
  "reviewLanguage": "en"
}
```

# Actor output Schema

## `results` (type: `string`):

Delivered rows in the default dataset.

## `output` (type: `string`):

Run counts, warnings and free-tier information.

# 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 = {
    "extensions": [
        "ddkjiahejlhfcafbddmgiahcphecmpfh"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/chrome-web-store").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 = { "extensions": ["ddkjiahejlhfcafbddmgiahcphecmpfh"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/chrome-web-store").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 '{
  "extensions": [
    "ddkjiahejlhfcafbddmgiahcphecmpfh"
  ]
}' |
apify call s-r/chrome-web-store --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/chrome-web-store"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/18QYK5PkysktR60ZZ/builds/Dvh7aCdwCf3y5k8y7/openapi.json