# Chrome Web Store & Firefox Add-ons Scraper — Users, Ratings (`yugenox/browser-extension-store-scraper`) Actor

Scrape Chrome Web Store and Firefox Add-ons extensions in one run: users, rating, reviews count, version, last update, size, developer, website, permissions, data handling and badges. By keyword, category, extension ID or the full catalog. Compare runs to track growth. No login.

- **URL**: https://apify.com/yugenox/browser-extension-store-scraper.md
- **Developed by:** [Yugenox Corp](https://apify.com/yugenox) (community)
- **Categories:** Developer tools, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 extensions

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 & Firefox Add-ons Scraper — Users, Ratings

Scrape **Chrome Web Store** and **Firefox Add-ons** extensions in one run, in one table: users, rating and number of
ratings, version, last update, size, languages, developer, website, support and privacy-policy links, permissions and
site access, data-handling disclosures, store badges (Featured, Established publisher, Recommended) and more.

Find extensions by **keyword**, by **category**, by **extension ID or link**, or read the **full catalog**. Turn on
**Compare with the previous run** and schedule it to track user growth, rating changes and new versions over time.

No login, no browser extension, no API key.

### What can you use it for?

- **Competitive intelligence** — see how many users your competitors' extensions have, how they are rated, how often
  they ship updates, and track growth week by week.
- **Market research** — size a niche ("vpn", "password manager", "seo", "ai writing"): how many extensions, how many
  users, who leads, who is new.
- **Lead generation for extension businesses** — developer names, websites, support links and business contact details
  of companies that publish extensions (EU trader disclosures).
- **Security and privacy reviews** — the permissions, site access and declared data handling of the extensions your
  team uses, Manifest V2 vs V3, minimum browser version.
- **Investors and analysts** — spot fast-growing extensions and the publishers behind them across both stores.

### How it works

| You give | Chrome Web Store | Firefox Add-ons |
|---|---|---|
| **Search terms** | every extension whose name contains your words, from the store's public index of all ≈375,000 listings | Mozilla's own add-on search (by relevance or your sort) |
| **Categories** | the top 32 extensions of each category, as the store's category page shows them | every extension in the category (up to 25,000), most-used first |
| **Extension IDs / links** | `kbfnbcaeplbcioakkpcpgfkobkghlhen` or the store link | `ublock-origin`, the GUID, the numeric ID or the store link |
| **Full catalog** | every listing in the store's index | every extension of every category |
| **Nothing** | the top 32 of all 18 categories | the most-used extensions |

Max extensions is shared fairly between your searches and categories, duplicates across sources are saved once, and
every run ends with a plain-English status message (and a RUN_REPORT record) saying what was found.

### Input

| Field | What it does |
|---|---|
| Stores | Chrome Web Store, Firefox Add-ons, or both (default both) |
| Search terms | Keywords, e.g. `vpn`, `grammar`, `seo`, `password manager` |
| Chrome categories / Firefox categories | Pick from the stores' own category lists |
| Extension IDs or links | Specific extensions from either store (category links work too) |
| Full catalog | Scrape whole stores instead of a search (large runs take hours — raise Timeout) |
| Max extensions | Total for the run (default 100, 0 = no limit) |
| Full Chrome details | Read each Chrome extension's store page for the update date, size, languages, developer, links, data handling, description and screenshots (on by default) |
| Minimum users / Minimum rating / Updated within (days) | Keep only the extensions you want |
| Firefox sort | Most users, top rated, recently updated, newest, trending, most weekly downloads or relevance |
| Compare with the previous run | Adds the previous run's users / rating / version, the change in users, and whether the extension is new |
| Language | Language of names and descriptions (`en`, `de`, `fr`, `ja`, `pt-BR` …) |

Example:

```json
{
  "stores": ["chrome", "firefox"],
  "searchTerms": ["vpn"],
  "maxItems": 20
}
```

### Output

One row per extension. A real row (Chrome, 2026-10-29, trimmed):

```json
{
  "store": "chrome",
  "id": "kbfnbcaeplbcioakkpcpgfkobkghlhen",
  "name": "Grammarly: AI Writing Assistant and Grammar Checker App",
  "url": "https://chromewebstore.google.com/detail/kbfnbcaeplbcioakkpcpgfkobkghlhen",
  "type": "extension",
  "shortDescription": "Grammarly for Chrome helps you write with confidence. Get AI support for grammar, clarity, and tone, from first draft to final edit.",
  "category": "productivity/communication",
  "categoryLabel": "Communication",
  "users": 40000000,
  "rating": 3.87,
  "ratingCount": 43165,
  "version": "14.1343.0",
  "manifestVersion": 3,
  "minBrowserVersion": "98",
  "createdAt": "2012-10-22T10:17:01.775Z",
  "updatedAt": "2026-10-28T13:22:59.694Z",
  "size": "18.16MiB",
  "sizeBytes": 19042140,
  "languages": ["English"],
  "developer": "Grammarly",
  "developerEmail": "support@grammarly.com",
  "website": "http://grammarly.com/",
  "supportUrl": "https://support.grammarly.com/",
  "privacyPolicyUrl": "https://www.grammarly.com/privacy-policy",
  "isTrader": true,
  "traderName": "Grammarly, Inc.",
  "traderAddress": "548 Market St Ste 35410, San Francisco, CA 94104-5401, US",
  "traderPhone": "+16282338294",
  "dunsNumber": "031633083",
  "featured": true,
  "establishedPublisher": true,
  "badges": ["Featured", "Established publisher"],
  "permissions": ["scripting", "sidePanel", "tabs", "notifications", "cookies", "identity", "storage"],
  "hostPermissions": ["http://*/*", "https://*/*"],
  "optionalPermissions": ["nativeMessaging", "clipboardRead"],
  "dataHandling": ["Personally identifiable information", "Personal communications", "Location", "User activity", "Website content"],
  "detailsIncluded": true,
  "source": "Chrome extension ID",
  "scrapedAt": "2026-10-29T19:21:34.516Z"
}
```

Firefox rows have the same columns plus `slug`, `guid`, `weeklyDownloads`, `reviewCount`, `license`, `tags` and
`requiresPayment` — e.g. uBlock Origin: 11,365,567 users, 242,069 weekly downloads, 4.8 from 22,260 ratings, version
1.75.0, badge "Recommended". Also in every row: description, icon, screenshots, `source` (which search, category or ID
found it) and `position`. With Compare on: `previousUsers`, `usersChange`, `previousRating`, `previousVersion`,
`versionChanged`, `isNewSinceLastRun`.

The dataset has two views: **Overview** and **Permissions & data**. Export to JSON, CSV, Excel or via the API.

### Pricing

Pay per result — you only pay for what you get:

| Event | Price | Per 1,000 |
|---|---|---|
| Extension saved (either store) | $0.0012 | $1.20 |
| Chrome store page read (full details, or checking your filters) | $0.0015 | $1.50 |
| Listing that added nothing (a Firefox search page or Chrome category page with no new extension, a section of the Chrome index with no match, an ID the store doesn't know) | $0.0005 | $0.50 |
| Run start | $0.001 | — |

So 1,000 Firefox extensions cost **$1.20**, 1,000 Chrome extensions with full details **$2.70**, and 1,000 Chrome
extensions from categories with "Full Chrome details" off **$1.20**. Listings that add extensions are paid for by those
extensions only. A store that refuses or shows a bot check is never charged.

### Tips

- **Chrome search order**: Chrome search terms are matched against the names in the store's public index, which is not
  sorted by popularity. To get *all* Chrome extensions for a word, set Max extensions high (or 0) and sort the dataset
  by `users`. Words match the start of a word in the first ~25 characters of the name: `vpn` finds "Free VPN for
  Chrome" but not "OpenVPN Connect" — add `openvpn` as a second term for that. A common word fills Max extensions in
  under a minute; a rare word is checked against the whole index, which takes 3–5 minutes.
- **Top extensions of a niche on Chrome**: pick the category — you get the store's top 32 by users, fast.
- **Filters save money on Chrome categories**: there, Minimum users and Minimum rating are checked before a store page
  is opened. Chrome search terms and the full catalog have to open each matching page to know its users, so with a
  high Minimum users every page that does not pass is still a "Chrome store page read" — set a maximum cost per run in
  the run options if you combine the two.
- **Weekly tracking**: schedule the same input with **Compare with the previous run** on; `usersChange` and
  `isNewSinceLastRun` show what moved.
- **Firefox users** are average daily users (Mozilla's figure); Chrome users are the rounded figure the store shows.
- **Big runs**: the full Chrome catalog is ≈375,000 store pages — raise the run Timeout to several hours.

### FAQ

**Is it legal to scrape the Chrome Web Store and Firefox Add-ons?**
This actor reads only public pages and Mozilla's public add-ons data that anyone can see without an account, it follows
both stores' robots.txt rules, and it does not collect reviews or reviewers. Scraping publicly available data is
generally lawful, but how you use the data is your responsibility — check the laws that apply to you (e.g. GDPR) and
consult a lawyer if in doubt.

**Does it access any private data?**
No. No login, no cookies, nothing behind an account. Developer contact details are limited to business contacts: an
e-mail is kept only when it is a role mailbox (support@, info@, hello@ …), and a trader's legal name, address, phone and
D-U-N-S number only when the trader is a company. Personal e-mail addresses and phone numbers in descriptions are
removed.

**Why does a Chrome category give only 32 extensions?**
That is what the store's category page shows (its top 32 by users). For more, use search terms or the full catalog.

**Can I get reviews?**
No — review texts are not collected.

**Why are some Chrome extensions without a developer name?**
Some developers publish with only an e-mail address; when that address is a personal one it is not included.

**What happens if a store blocks the run?**
The run stops that store with a plain message and still finishes successfully with whatever was collected — you are not
charged for refused requests.

# Actor input Schema

## `stores` (type: `array`):

Which stores to scrape: Chrome Web Store, Firefox Add-ons, or both. Extension IDs and links you paste are always read from their own store.

## `searchTerms` (type: `array`):

Keywords, e.g. "vpn", "grammar", "seo", "password manager". Firefox: Mozilla's own add-on search (by relevance unless you pick a sort below). Chrome: every extension whose name contains your words, found in the store's public index of all extensions (≈375,000; the index lists the first ~25 characters of each name). Words match the start of words, e.g. "vpn" finds "Free VPN for Chrome". The index is read section by section until Max items is reached: a common word takes 15–60 seconds, a rare word that has to be checked against the whole index 3–5 minutes.

## `chromeCategories` (type: `array`):

Chrome Web Store categories. Each gives the store's top 32 extensions of that category (by users, as the category page shows them).

## `firefoxCategories` (type: `array`):

Firefox Add-ons categories. Each gives ALL extensions of the category (up to Mozilla's limit of 25,000 per category), most-used first unless you pick another sort.

## `extensionIds` (type: `array`):

Specific extensions. Chrome: the 32-letter ID (e.g. "kbfnbcaeplbcioakkpcpgfkobkghlhen") or the chromewebstore.google.com link. Firefox: the add-on slug (e.g. "ublock-origin"), its ID or GUID, or the addons.mozilla.org link. Category links work too.

## `fullCatalog` (type: `boolean`):

Scrape the whole store(s) instead of a search: Chrome — every extension in the store's public index (≈375,000 pages, so set Max items and Timeout to match; with Search terms, only names that match); Firefox — every extension of every category, most-used first. Large runs take hours.

## `maxItems` (type: `integer`):

Maximum number of extensions saved for the whole run, shared fairly between your searches and categories. 0 = no limit.

## `includeDetails` (type: `boolean`):

Chrome categories list extensions with users, rating, version and permissions. Keep this on to also read each extension's store page: last update, size, languages, developer, support/privacy links, data-handling disclosures, full description and screenshots (charged as "Chrome page read"). Chrome searches, IDs and the full catalog always read the page. Firefox rows are always complete.

## `minUsers` (type: `integer`):

Only keep extensions with at least this many users (Chrome: users shown on the store; Firefox: average daily users). Leave empty for all.

## `minRating` (type: `string`):

Only keep extensions rated at least this (0–5), e.g. "4" or "4.5". Leave empty for all.

## `updatedWithinDays` (type: `integer`):

Only keep extensions updated in the last N days. Leave empty for all.

## `firefoxSort` (type: `string`):

Order of Firefox results. Auto = relevance for search terms, most users for categories and the catalog.

## `compareWithPreviousRun` (type: `boolean`):

Track growth: each row gets the users, rating and version from the previous run with the same input, the change in users, whether the version changed, and whether the extension is new since then. Ideal for a daily or weekly schedule. The memory is kept in a key-value store named "browser-extension-store-scraper-state" in your account.

## `language` (type: `string`):

Language of names and descriptions, e.g. "en", "de", "fr", "es", "ja", "pt-BR". Extensions that are not translated stay in their own language.

## `proxyConfiguration` (type: `object`):

Apify Proxy (datacenter) is the default and comes with every Apify plan. Runs always start on datacenter IPs (also when you pick residential here); if a store keeps refusing them, the run switches to residential proxies by itself when your account has them. Your own proxy URLs are used as they are.

## Actor input object example

```json
{
  "stores": [
    "chrome",
    "firefox"
  ],
  "searchTerms": [
    "vpn"
  ],
  "fullCatalog": false,
  "maxItems": 20,
  "includeDetails": true,
  "firefoxSort": "auto",
  "compareWithPreviousRun": false,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped extensions.

## `run` (type: `string`):

Status and statistics for this run.

## `report` (type: `string`):

RUN_REPORT: how the run ended, counts per store, requests and proxy use.

# 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 = {
    "stores": [
        "chrome",
        "firefox"
    ],
    "searchTerms": [
        "vpn"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yugenox/browser-extension-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "stores": [
        "chrome",
        "firefox",
    ],
    "searchTerms": ["vpn"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("yugenox/browser-extension-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 '{
  "stores": [
    "chrome",
    "firefox"
  ],
  "searchTerms": [
    "vpn"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call yugenox/browser-extension-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yugenox/browser-extension-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 <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/CfUlNXSecrgSsiFp3/builds/i3oLK3dAO3vOM39Fx/openapi.json