# Chrome Web Store Scraper & Database & MCP (`aross/cws-intelligence`) Actor

Instant search & analytics for 262K+ Chrome extensions. AI semantic search,
historical tracking (users/ratings/versions), competitor monitoring, developer
profiles. Pre-built database — millisecond responses, no scraping delays.
API & MCP server.

- **URL**: https://apify.com/aross/cws-intelligence.md
- **Developed by:** [Aleksandr Ross](https://apify.com/aross) (community)
- **Categories:** Developer tools, MCP servers, AI
- **Stats:** 8 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 keyword searches

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Chrome Extension Intelligence — CWS Database, Analytics & MCP

Search and analyze **262,000+ Chrome Web Store extensions** instantly. AI semantic search, 90-day historical tracking, competitive intelligence, developer analytics — all from a pre-built database with millisecond responses. Connect via REST API or use the built-in MCP server to give your AI agent direct access to Chrome extension data.

***

### Why not a real-time scraper?

Most Chrome Web Store scrapers fetch data on demand — slow, frequently blocked by Google, and with no historical context. CWS Intelligence works differently: all data is pre-indexed and continuously updated, so every query returns in milliseconds with history already attached.

| | Real-time CWS scrapers | CWS Intelligence |
|---|---|---|
| Response time | 5–30 seconds | Milliseconds |
| Blocking / downtime risk | High | None |
| Historical data (users, ratings, versions) | ❌ | ✅ Weekly snapshots, growing over time |
| AI semantic search | ❌ | ✅ |
| Developer profiles & portfolio | ❌ | ✅ |
| Trending detection | ❌ | ✅ 7 / 30 / 90-day growth |
| Works as MCP server | ❌ | ✅ |

***

### What it does

This Actor provides API access to a continuously updated Chrome Web Store database. Key capabilities:

- **Keyword search with filters** — category, min users, min rating, sorting
- **AI semantic search** — find extensions by meaning, not just keywords (e.g., *"tools that help organize browser tabs"*)
- **Extension details** — full metadata: permissions, screenshots, description, manifest version
- **Historical tracking** — user count, rating, and version changes over time (up to 90 days)
- **Developer profiles** — aggregated stats and full extension lists per developer
- **Trending extensions** — fastest-growing by user count over 7 / 30 / 90-day periods
- **Side-by-side comparison** — compare 2–5 extensions at once
- **Similar extensions** — AI-powered recommendations based on description embeddings

***

### Use cases

**Find market gaps before building**
Search a category, filter by user count, sort by last-updated date — identify extensions with 50K+ users that haven't been updated in 2+ years. These are your displacement opportunities or acquisition targets.

**Track a competitor before launching**
Pull 90-day history for any extension to see whether it's growing, plateauing, or declining. Know their trajectory before you enter the market.

**Validate demand without building**
Use semantic search to find all extensions solving a problem you're considering. If the top result has 200K users and 2 stars — that's your market signal.

**Feed your AI agent with extension intelligence**
Connect via MCP and let Claude, GPT-4o, or any AI agent query the database directly. Ask: *"Which Notion extensions are growing fastest this month?"* and get a structured answer in seconds.

**Spot brand squatters and copycats**
Search your brand name, filter by recently created — catch copycat extensions before they steal your traffic.

**Build developer prospecting lists**
Search developers by name or keyword, get aggregated stats across their entire portfolio — useful for partnership outreach or acquisition research.

***

### Data freshness

The entire database is re-crawled **once per week** — every extension gets a fresh snapshot on the same cadence.

- **Total extensions indexed:** 262,000+
- **Update frequency:** Weekly (full re-crawl of all extensions)
- **History depth:** Growing weekly — 1 week of snapshots now, expanding automatically over time
- **Coverage:** All public Chrome Web Store extensions

> The history window grows with each passing week. The longer the Actor runs, the richer the trend data you can query.

***

### Input parameters

| Parameter | Type | Description |
|---|---|---|
| `action` | string | **Required.** One of the actions listed below |
| `query` | string | Search text (keyword or natural language for semantic search) |
| `extensionId` | string | 32-char extension ID |
| `extensionIds` | string\[] | Array of 2–5 extension IDs (for `compare_extensions`) |
| `developerName` | string | Developer name (exact for `get_developer`, partial for `search_developers`) |
| `category` | string | Category slug filter (e.g., `productivity/tools`) |
| `minUsers` | integer | Minimum user count filter |
| `minRating` | number | Minimum rating filter (0–5) |
| `sort` | string | Sort by: `users`, `rating`, `name`, `updated`, `created`, `reviews`, `size` |
| `sortDirection` | string | `asc` or `desc` |
| `limit` | integer | Results per page (1–100, default 20) |
| `page` | integer | Page number |
| `historyDays` | integer | Limit history to last N days (bounded by available snapshot depth) |
| `trendingPeriod` | string | `7d`, `30d`, or `90d` |

***

### Actions

| Action | Description | Required params |
|---|---|---|
| `search` | Keyword search with filters and sorting | — |
| `semantic_search` | AI search by meaning | `query` |
| `get_extension` | Full extension details | `extensionId` |
| `get_extension_history` | Metric snapshots over time | `extensionId` |
| `get_developer` | Developer profile + extensions | `developerName` |
| `search_developers` | Search developers | — |
| `get_categories` | All categories with counts | — |
| `get_stats` | Database statistics | — |
| `get_similar` | AI-powered similar extensions | `extensionId` |
| `get_trending` | Fastest-growing extensions | — |
| `compare_extensions` | Side-by-side comparison | `extensionIds` |

***

### Output

Results are pushed to the default dataset. Structure depends on the action:

- `search` / `semantic_search` / `get_trending` / `get_similar` — array of extension objects
- `get_extension` — single extension object with full metadata
- `get_extension_history` — snapshots array + text field changes
- `get_developer` — developer profile with aggregated stats and extensions list
- `search_developers` — array of developer profiles
- `get_categories` — array of categories with extension counts
- `get_stats` — database summary (total extensions, last update, coverage)
- `compare_extensions` — array of extension objects with 30-day history

For paginated actions, metadata (`total`, `page`, `limit`) is stored in the key-value store under the `metadata` key.

#### Sample output

**`search` / `get_trending` / `get_similar`** return extension objects:

```json
{
  "id": "cjpalhdlnbpafiamejdnhcphjbkeiagm",
  "name": "AdBlock — best ad blocker",
  "developer": "AdBlock",
  "users": 65000000,
  "rating": 4.5,
  "rating_count": 280000,
  "version": "6.8.0",
  "category": "productivity/tools",
  "manifest_version": 3,
  "last_updated": "2026-03-15",
  "permissions": ["storage", "declarativeNetRequest"]
}
```

**`get_extension_history`** returns metric snapshots:

```json
{
  "extension_id": "cjpalhdlnbpafiamejdnhcphjbkeiagm",
  "snapshots": [
    { "date": "2026-03-01", "users": 64200000, "rating": 4.5, "version": "6.7.9" },
    { "date": "2026-03-15", "users": 65000000, "rating": 4.5, "version": "6.8.0" }
  ],
  "growth_30d": 800000,
  "growth_pct_30d": 1.25
}
```

***

### Pricing

Pay only for what you use. Most research sessions cost less than $1.

A typical workflow — 10 keyword searches, 5 extension detail lookups, 2 history checks — costs around **$0.25**. The pricier AI operations (semantic search, similar extensions) use embedding models at $0.04/call, still far cheaper than any manual research time.

| Event | Price |
|---|---|
| Database Stats | $0.001 |
| Categories List | $0.002 |
| Extension Details | $0.005 |
| Developer Profile | $0.010 |
| Keyword Search | $0.015 |
| Developer Search | $0.015 |
| Compare Extensions | $0.020 |
| Extension History | $0.030 |
| Trending Extensions | $0.030 |
| AI Semantic Search | $0.040 |
| Similar Extensions (AI) | $0.040 |

***

### MCP Server (Standby Mode)

This Actor doubles as an MCP server when running in Standby mode. AI agents connect to the `/mcp` endpoint using the Model Context Protocol to query the database programmatically.

**Available MCP tools:** `search_extensions`, `semantic_search`, `get_extension`, `get_extension_history`, `get_developer`, `search_developers`, `get_categories`, `get_stats`, `get_similar`, `get_trending`, `compare_extensions`

#### Connect from Claude Desktop

```json
{
  "mcpServers": {
    "cws-intelligence": {
      "type": "url",
      "url": "https://aross--cws-intelligence.apify.actor/mcp?token=***"
    }
  }
}
```

#### Connect from Cursor

```json
{
  "mcpServers": {
    "cws-intelligence": {
      "type": "url",
      "url": "https://aross--cws-intelligence.apify.actor/mcp?token=***",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Connect from Windsurf

```json
{
  "mcpServers": {
    "cws-intelligence": {
      "serverUrl": "https://aross--cws-intelligence.apify.actor/mcp?token=***"
    }
  }
}
```

#### Connect from any MCP-compatible client

- **Endpoint:** `https://aross--cws-intelligence.apify.actor/mcp?token=***`
- **Auth:** Bearer token (your Apify API token)
- **Protocol:** Model Context Protocol over HTTP/SSE

***

### Examples

**Find tab management extensions with 10K+ users**

```json
{
  "action": "search",
  "query": "tab manager",
  "minUsers": 10000,
  "sort": "users"
}
```

**Find underserved extensions: high users, low rating**

```json
{
  "action": "search",
  "category": "productivity/tools",
  "minUsers": 50000,
  "sort": "rating",
  "sortDirection": "asc"
}
```

**Semantic search for privacy tools**

```json
{
  "action": "semantic_search",
  "query": "tools that block trackers and protect browsing privacy"
}
```

**Track an extension's growth over 90 days**

```json
{
  "action": "get_extension_history",
  "extensionId": "cjpalhdlnbpafiamejdnhcphjbkeiagm",
  "historyDays": 90
}
```

**Compare top ad blockers side by side**

```json
{
  "action": "compare_extensions",
  "extensionIds": [
    "cjpalhdlnbpafiamejdnhcphjbkeiagm",
    "gighmmpiobklfepjocnamgkkbiglidom"
  ]
}
```

**Get fastest-growing extensions this week**

```json
{
  "action": "get_trending",
  "trendingPeriod": "7d",
  "limit": 10
}
```

**Find all extensions by a prolific developer**

```json
{
  "action": "get_developer",
  "developerName": "Google LLC"
}
```

**Find extensions similar to a known one**

```json
{
  "action": "get_similar",
  "extensionId": "cjpalhdlnbpafiamejdnhcphjbkeiagm"
}
```

# Actor input Schema

## `action` (type: `string`):

What operation to perform

## `query` (type: `string`):

Search query text. For 'search': keyword match. For 'semantic\_search': natural language (e.g. 'tools for managing browser tabs efficiently')

## `extensionId` (type: `string`):

32-character Chrome extension ID. Required for: get\_extension, get\_extension\_history, get\_similar

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

Array of extension IDs to compare (2-5). Required for: compare\_extensions

## `developerName` (type: `string`):

Developer name (exact for get\_developer, partial match for search\_developers)

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

Filter by category slug (e.g. 'productivity/tools', 'make\_chrome\_yours/privacy')

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

Filter: minimum number of users

## `minRating` (type: `number`):

Filter: minimum rating (0-5)

## `sort` (type: `string`):

Sort field for search results

## `sortDirection` (type: `string`):

Sort direction for results

## `limit` (type: `integer`):

Maximum number of results (default: 20, max: 100)

## `page` (type: `integer`):

Page number for paginated results

## `historyDays` (type: `integer`):

For get\_extension\_history: limit to last N days (omit for full history)

## `trendingPeriod` (type: `string`):

For get\_trending: time period to analyze

## Actor input object example

```json
{
  "action": "search",
  "sort": "users",
  "sortDirection": "desc",
  "limit": 20,
  "page": 1,
  "trendingPeriod": "30d"
}
```

# Actor output Schema

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

Query results — extensions, developers, stats, or history depending on the chosen action

## `metadata` (type: `string`):

Pagination metadata (total, page, limit) for list actions

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("aross/cws-intelligence").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("aross/cws-intelligence").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 '{}' |
apify call aross/cws-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aross/cws-intelligence"
        }
    }
}

```

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/XwI6LroN4G3Bf2mRI/builds/9hFqVusgZEriZ5RTq/openapi.json