# Chrome Web Store Scraper - Full Catalogue & Dev Emails (`gio21/chrome-web-store-scraper`) Actor

Extract Chrome Web Store extension data by URL, keyword or the entire ~320K catalogue: users, rating, category, developer name and email, reviews included at no extra charge. $0.005/extension.

- **URL**: https://apify.com/gio21/chrome-web-store-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** Developer tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 6 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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 Scraper - Full Catalogue & Dev Emails

Extract structured data for any Chrome Web Store extension: rating, weekly
users, category, developer name and email, version, size, last-updated
date, supported languages, description and user reviews. Scrape specific
extensions by URL, discover extensions by keyword, or crawl the entire
\~320,000-extension catalogue.

### Why use this scraper

The Chrome Web Store has no public API for extension metadata, developer
contact details or reviews, yet it is the main distribution channel for
every browser extension business: productivity tools, ad blockers,
scrapers, AI assistants and thousands of niche utilities. Anyone doing
competitor research, sourcing leads for extension developers, or tracking
how a category of extensions is trending needs a way to pull hundreds or
thousands of listings into one structured dataset instead of opening each
extension page by hand.

Extension data also shifts constantly: user counts grow, new versions ship,
new competitors launch. Running this actor on a schedule against the same
keyword or category keeps a dataset current without anyone manually
re-checking the store.

### Overview

Give the actor specific extension URLs or IDs, one or more search keywords,
or set `scrapeAllApps` to crawl the whole store via its own sitemap, and it
returns one record per extension with every public field the store exposes,
including the developer's contact email when they chose to publish one. A
50-extension keyword search finishes in under two minutes. Cost is $0.005
per extension actually scraped; failed or empty pages are never charged.

### Supported inputs

- **Specific extensions** (`extensionUrls`) - full detail-page URLs or raw
  32-character extension IDs. The fastest mode, since no search or crawl is
  needed.
- **Keyword search** (`queries`) - one or more search terms (e.g. "ad
  blocker", "password manager"); every matching extension is discovered and
  then fully scraped.
- **Full catalogue** (`scrapeAllApps: true`) - crawls every extension in the
  store via its sitemap, capped by `maxItems`; `sitemapShardLimit` lets you
  sample a fraction of the ~33 sitemap shards instead of the whole store.
- **Reviews** (`includeReviews: true`, with `maxReviewsPerExtension` and
  `reviewsLanguage`) - adds a `reviews` array to each extension, and works
  with any of the three modes above.

### Use cases

- **Competitor and market research** - pull every extension in a category
  or matching a keyword to see how many competitors exist, their user
  counts and their ratings.
- **Developer-lead generation** - crawl a category or keyword and collect
  `developerEmail` for outreach to extension makers (agencies, acquirers,
  ad networks).
- **Extension due diligence** - before acquiring or partnering with an
  extension, pull its full profile and recent reviews in one call.
- **Trend tracking** - run the same keyword or category on a schedule and
  compare `users` and `ratingCount` over time to see which extensions are
  growing.
- **Review mining** - attach reviews to a list of extensions to analyse
  complaints, feature requests or sentiment at scale.

### How it works

Extension detail pages and the sitemap are read directly over HTTP, which
keeps those modes fast. Keyword search uses a real browser because the
store's search results are rendered client-side; once the matching
extensions are identified, their detail pages are then read the same way as
the other modes. Reviews are paged from the store's own review endpoint in
batches of 10 up to `maxReviewsPerExtension`.

### Input configuration

**Mode 1: specific extensions by ID**

```json
{
  "extensionUrls": ["cjpalhdlnbpafiamejdnhcphjbkeiagm", "ublock-origin"],
  "maxItems": 10
}
```

**Mode 2: keyword search with reviews**

```json
{
  "queries": ["ad blocker"],
  "maxItems": 50,
  "includeReviews": true,
  "maxReviewsPerExtension": 20
}
```

**Mode 3: sample of the full catalogue**

```json
{
  "scrapeAllApps": true,
  "maxItems": 500,
  "sitemapShardLimit": 2
}
```

### Output sample

Real output from a keyword search for "upwork scraper" (trimmed to the
main fields):

```json
{
  "id": "aahgcabppapofkelkchbdhkemingdemg",
  "name": "Upwork Email Scraper",
  "url": "https://chromewebstore.google.com/detail/aahgcabppapofkelkchbdhkemingdemg",
  "rating": 1,
  "ratingCount": 1,
  "users": 224,
  "category": "Tools",
  "categorySlug": "tools",
  "version": "1.0.1",
  "size": "1.29MiB",
  "lastUpdated": "2024-08-26T04:57:12.000Z",
  "developer": "LetsFaster",
  "developerEmail": "help@letsfaster.com",
  "tagline": "One-click scrape emails from Upwork specific profile from search engine based on your keyword as Excel/CSV/JSON/HTML/XML file.",
  "languageCount": 48,
  "websiteUrl": "https://soleads.ai/",
  "query": "upwork scraper",
  "searchPosition": 3
}
```

### Key output fields

| Field | Type | Description |
|-------|------|--------------|
| `id` | String | 32-character extension ID |
| `name` / `tagline` / `description` | String | Extension name, short summary and full description |
| `url` / `iconUrl` | String | Detail page and icon image URL |
| `rating` / `ratingCount` | Number | Average rating and number of ratings |
| `users` | Number | Weekly user count as shown on the store |
| `category` / `categorySlug` | String | Store category |
| `version` / `size` / `lastUpdated` | String | Current version, package size, last-update date |
| `developer` | String | Developer or publisher name |
| `developerEmail` | String | Contact email, only present when the developer published one |
| `languages` / `languageCount` | Array / Number | Supported interface languages |
| `websiteUrl` / `privacyPolicyUrl` | String | Developer links, when present |
| `query` / `searchPosition` | String / Number | The keyword that found this extension and its rank in the results (keyword-search mode) |
| `reviews` | Array | `{ author, rating, text, postedAt, version, language }` per review, only when `includeReviews` is on |

### Pricing

| Event | Price |
|-------|-------|
| Extension scraped | $0.005 |

Pay-per-event. Only successfully scraped extensions are charged; failed or
empty pages cost nothing. Reviews are included in the same per-extension
charge when `includeReviews` is on, there is no separate per-review fee.

### What makes this richer than the competition

- **automation-lab/chrome-web-store-reviews-scraper** (19 users/30d) covers
  reviews only, not the extension's own profile (rating, users, category,
  developer, email), and charges per review on top of a run fee.
- **tugelbay/chrome-web-store-intelligence** (11 users/30d) covers similar
  extension and search data, but charges a separate event per search
  keyword in addition to per-extension pricing.

This actor returns the full extension profile, including the developer's
contact email when published, in every mode, and includes reviews in the
same flat per-extension price with no extra review charge. It is also one
of the few in the Store that can crawl the entire catalogue via the
sitemap rather than being limited to search results or a fixed list, which
matters for lead-generation and market-sizing use cases where the goal is
coverage of a whole category, not just the top few results a keyword
search happens to surface.

### Notes & limitations

- `developerEmail` is `null` when the developer did not publish a contact
  address on their profile; the actor never guesses one.
- Keyword search surfaces whatever the store's own search returns for that
  term, the same extensions a person typing the keyword into the store
  would see.
- Full-catalogue mode (`scrapeAllApps`) can return a very large number of
  extensions; use `maxItems` or `sitemapShardLimit` to cap a run before
  scraping the whole store.
- `users` reflects the weekly user count the store displays at scrape time;
  it is not a historical series, run the actor again later to track
  changes.

### FAQ

**Does it need a Google or developer account?**
No, all data is read from public extension and store pages.

**Can I scrape by category instead of keyword?**
Not directly, there is no category input. Use a keyword that matches the
category (e.g. "password manager") or sample the full catalogue and filter
the output by `category` yourself.

**Why is `developerEmail` sometimes empty?**
Because the developer did not list a public contact email on their Chrome
Web Store profile. The actor reports exactly what the store shows.

**How big can a full-catalogue run get?**
The catalogue has roughly 320,000 extensions across about 33 sitemap
shards. Always set `maxItems` (or `sitemapShardLimit` to sample fewer
shards) unless you intend to scrape the whole store.

**Are reviews charged separately?**
No, `includeReviews` adds the `reviews` array to the same extension record
at no extra cost, you only pay the per-extension price.

**Can I combine specific extensions and a keyword search in one run?**
Yes, provide both `extensionUrls` and `queries`; the actor scrapes the
specific extensions and the keyword matches together, deduplicated by ID.

### For AI Agents & LLM Apps

This actor is callable from any MCP-compatible AI assistant through the
[Apify MCP server](https://mcp.apify.com), and directly from code through
the Apify API.

**Via MCP** (`mcp.apify.com`): add the Apify MCP server to your AI
assistant (Claude, ChatGPT, or any MCP client) and call the
`gio21/chrome-web-store-scraper` actor by name with `queries` or
`extensionUrls`. The assistant gets back structured JSON it can reason
over directly.

**Via API** (`run-sync-get-dataset-items`), for a synchronous call that
returns the dataset items in the same request:

```bash
curl "https://api.apify.com/v2/acts/gio21~chrome-web-store-scraper/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"queries": ["ad blocker"], "maxItems": 50}'
```

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by,
or sponsored by Google or the Chrome Web Store. All trademarks mentioned
are the property of their respective owners.

### SEO Keywords

chrome web store scraper, chrome extension scraper, chrome web store api, extension developer email scraper, chrome extension reviews scraper, browser extension data scraper

# Actor input Schema

## `extensionUrls` (type: `array`):

Specific extensions to scrape. Accepts full detail URLs (https://chromewebstore.google.com/detail/.../<id>) or raw 32-char extension IDs.

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

Keywords to search the Chrome Web Store for (e.g. "ad blocker", "screenshot"). Discovered extensions are then fully scraped. Search uses a real browser, so it is slower than the other modes.

## `scrapeAllApps` (type: `boolean`):

Crawl EVERY extension via the store sitemap (~320,000 extensions). Use "Max extensions" to cap the run. Ideal for market intelligence and developer-lead generation.

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

Maximum number of extensions to scrape across all modes. Set 0 for no limit (only sensible with specific URLs).

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

Attach user reviews (author, rating, text, date, version, language) to each extension under a "reviews" array.

## `maxReviewsPerExtension` (type: `integer`):

Upper bound on reviews collected per extension when "Include reviews" is on. Reviews are paged in batches of 10.

## `reviewsLanguage` (type: `string`):

Interface/review language code (en, pt, de, es, fr, ja, ...). Affects review language filtering and localised labels.

## `sitemapShardLimit` (type: `integer`):

Full-catalogue mode only. Limit how many of the ~33 sitemap shards to enumerate (0 = all). Useful for sampling the catalogue.

## Actor input object example

```json
{
  "extensionUrls": [
    "cjpalhdlnbpafiamejdnhcphjbkeiagm"
  ],
  "queries": [
    "ad blocker",
    "password manager"
  ],
  "scrapeAllApps": false,
  "maxItems": 100,
  "includeReviews": false,
  "maxReviewsPerExtension": 20,
  "reviewsLanguage": "en",
  "sitemapShardLimit": 0
}
```

# 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 = {
    "extensionUrls": [
        "https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/chrome-web-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 = { "extensionUrls": ["https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm"] }

# Run the Actor and wait for it to finish
run = client.actor("gio21/chrome-web-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 '{
  "extensionUrls": [
    "https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm"
  ]
}' |
apify call gio21/chrome-web-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gio21/chrome-web-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/OixBiVce55Mf3Sg4V/builds/J6E2yj6HuhWue0YYX/openapi.json