# Chrome, Firefox, VS Code & JetBrains Plugins Tracker (`signalscope-data/extension-marketplaces-tracker`) Actor

Chrome Web Store, Firefox, VS Code, Open VSX & JetBrains plugins in one run: users, ratings, reviews + complaint insights, permission risk, publishers, niche reports, alerts. $1.50/1k.

- **URL**: https://apify.com/signalscope-data/extension-marketplaces-tracker.md
- **Developed by:** [Bin](https://apify.com/signalscope-data) (community)
- **Categories:** Developer tools, Marketing, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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, Firefox, VS Code & JetBrains Plugins Tracker

Search, rank and **monitor extensions and JetBrains plugins on five marketplaces in one run**: the **Chrome Web Store**, **Firefox Add-ons**, the **VS Code Marketplace**, **Open VSX** (the registry behind VSCodium, Cursor, Windsurf, Gitpod, Eclipse Theia) and the **JetBrains Marketplace** (plugins for IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, PhpStorm, CLion, Android Studio and other JetBrains IDEs). You get one clean, unified record per extension with users/installs, ratings, version, last update, categories, tags, repository and license. Chrome and Firefox extensions also come with their **permissions, host permissions and a permission risk score** (Chrome: manifest version, size and privacy policy URL; Firefox: declared data collection).

Add **user reviews** with one switch: star rating, text, date, extension version, helpful votes and the **developer's reply**, from Chrome, Firefox, VS Code and JetBrains. Filter to complaints only (`maxReviewRating: 2`) or to the last 30 days, sort Chrome reviews by newest, most helpful or lowest rating, and in monitor mode get only reviews posted since the last run.

Don't want to read 1,000 reviews? Turn on **review insights** (`includeReviewInsights: true`) and get one row per extension that says **what users complain about and what they love**: complaint themes (bugs, "broke after the update", Manifest V3 / browser compatibility, memory, paywall, ads & hijacking, privacy, login...) with quotes, praise themes, feature requests, the rating trend, **which version made users angry**, and a side-by-side comparison of competitors.

Need **developers instead of extensions**? Set `outputLevel: "publishers"` and get one row per publisher per marketplace with its **portfolio**: extension count, total installs, total ratings and weighted average rating, top extension, website domain, GitHub repositories, last update, stale extensions and the full extensions list, plus alerts when a publisher ships a new extension, removes one or gains installs.

Thinking about building an extension? Turn on the **niche market report** (`marketReportOnly: true`) and get one row per marketplace and keyword that sizes the niche: total extensions, installs and concentration (how much the top 1 / 3 / 10 hold), ratings, update freshness, new launches, permission risk, Chrome extensions still on Manifest V2, top publishers, and the openings: **weak incumbents** (big but badly rated), **stale incumbents** (big but abandoned) and **rising newcomers**.

Turn on change tracking and the Actor compares each run with the previous one. It flags **new extensions, new version releases, install jumps, rating changes, rank moves, newly added permissions and extensions taken down from the store**, so a daily schedule becomes an alert feed (and an extension security monitor for IT teams).

No login, no API key, no browser. It uses the marketplaces' public data endpoints only, so it's fast and cheap.

### Why this one?

- **5 marketplaces, 1 schema.** Compare a Chrome extension with its Firefox version, the same extension on VS Code vs Open VSX vs JetBrains, or a browser extension vs its IDE plugin, without stitching five scrapers together.
- **JetBrains plugins with full detail (new).** Search or browse the JetBrains Marketplace by keyword, tag (`AI`, `Code Tools`, `Theme`...) or IDE (`pycharm`, `webstorm`, `goland`...) and get downloads, rating, rating count, latest version, last update, vendor, verified-vendor flag, tags, pricing model (Free / Freemium / Paid), source code, docs and issue-tracker links for every plugin, plus reviews with the vendor's reply.
- **Chrome Web Store with full detail.** Users, rating, rating count, version, last update, developer, category, permissions and host permissions for every search result (not just the first 10).
- **Reviews from 4 stores in the same run.** Chrome Web Store, Firefox Add-ons, VS Code Marketplace and JetBrains Marketplace reviews come back as `recordType: "review"` rows next to the extension rows, with developer replies, so you can see what users complain about and how fast competitors answer.
- **Change detection built in.** It reports `new`, `new-version`, `installs-up` / `installs-down`, `rank-up` / `rank-down`, `entered-list` and `rating-change`, and you set the thresholds.
- **Strict keyword matching.** Marketplace search returns loosely related, popular extensions when sorted by installs. This Actor keeps only the results that actually contain your keywords.
- **Abandoned-extension finder.** `daysSinceUpdate` + `isStale` flag extensions not updated for N days. These are acquisition targets, gaps to fill, or security risks to remove.
- **Publisher (developer) level (new).** `outputLevel: "publishers"` turns any search into a list of publishers with their whole portfolio on that marketplace (VS Code, Open VSX, Firefox and JetBrains: the complete list by publisher; Chrome: found by searching the developer name and matched by Chrome's developer id). Alerts: `new`, `new-extension` (with `newExtensions`), `extension-removed`, `installs-up` / `installs-down`, `rating-change`. Company-level data only: no emails, phones or addresses.
- **Permission risk & drift monitor (new).** Every Chrome and Firefox row gets `permissionRiskScore` (0–100), `permissionRiskLevel` (low < 15, medium 15+, high 40+, critical 80+; access to all websites alone = 40), `allSitesAccess` and `riskyPermissions` with a plain-English reason ("can read and change cookies"). In monitor mode you get `permissions-added` / `permissions-removed` (with `addedPermissions`), `risk-up`, and `removed-from-store` when a watched extension is taken down or unpublished (alerted once; `back-in-store` if it returns). New permissions after an update are the classic sign of a sold or hijacked extension. Filter with `minPermissionRisk: "high"` for a security audit.
- **Niche market report (new).** `includeMarketReport` / `marketReportOnly` adds one `recordType: "market-report"` row per marketplace × keyword / publisher / category: total in store, total and median installs, install distribution, top 1 / 3 / 10 install share, average and rating-weighted rating, pricing mix, verified-publisher share, update freshness, new extensions in the last 90 / 365 days, permission-risk mix, Chrome Manifest V2 leftovers, VS Code weekly trending, top publishers, **weak incumbents**, **stale incumbents**, **rising newcomers** and plain-English `opportunitySignals`. With a monitor it adds `sinceLastRun` (new extensions, installs change %, new versions, fastest growing). No other extension Actor on Apify compares niches across Chrome, Firefox, VS Code and JetBrains like this.
- **Review insights & competitor comparison (new).** `includeReviewInsights` adds one `recordType: "review-insights"` row per extension from its newest reviews: rating distribution and trend (last 90 days vs older), **14 complaint themes tuned for browser extensions and IDE plugins** (bugs, broke after update, browser / IDE compatibility incl. Manifest V3, performance & memory, breaks sites / conflicts, ads & hijacking, privacy & permissions, paywall & pricing, login, sync & data loss, accuracy, UI, developer support) with example quotes, **9 praise themes** (easy to use, just works, lightweight, privacy-friendly, responsive developer...), feature requests, top complaint phrases, developer reply rate and speed, and **rating by extension version with `problemReleases`** (a version rated 0.7+ stars below the others: the release that broke it). With 2+ extensions a `review-comparison` row benchmarks them per 100 reviews: relative weaknesses and strengths. Other review scrapers give you raw text; this tells you where a competitor is beatable.
- **Watchlists.** Track exact extensions by ID or marketplace URL, or every extension of a publisher.

### Use cases

- **Developer-tool companies & DevRel:** track your extension's installs and rank against competitors every day, on every marketplace.
- **Market research / investors:** see which AI coding assistants are growing fastest on VS Code and JetBrains IDEs, and which new ones launched this week in the "AI" category.
- **JetBrains plugin developers:** track your plugin's downloads, rating and rank against competing IntelliJ / PyCharm / WebStorm plugins, and collect new reviews of yours and theirs every day.
- **Indie hackers & product teams deciding what to build:** run `marketReportOnly` on 5–10 keyword ideas across Chrome, Firefox and VS Code and compare: is the niche dominated by one extension, are the leaders abandoned or badly rated, do newcomers still get traction?
- **Extension acquirers & indie hackers:** find popular but stale extensions (high installs, `isStale: true`) to buy, fork or replace.
- **Security & IT teams:** watch the list of Chrome and Firefox extensions your company allows. Get an alert when one adds permissions, gets riskier, ships a new version or is removed from the store; audit a whole category with `minPermissionRisk`.
- **Browser-extension makers:** track your Chrome Web Store users and rating next to your competitors every day.
- **Product & support teams:** collect every new 1-2 star review of your extension (and your competitors') each morning: bug reports, churn reasons and feature requests, with the version they refer to.
- **Competitor teardown before you build:** search your niche with `includeReviewInsights` and see in one table which competitor users leave because of the paywall, which one broke after an update, and what everybody praises (the bar you must meet).
- **Partnerships, BD & dev-tool sales:** build lists of extension publishers in a niche (one row per developer, with website domain and portfolio reach) and see who is shipping new extensions.
- **Open VSX coverage gaps:** find popular VS Code extensions that are missing or outdated on Open VSX (for Cursor/VSCodium users).

### Input

| Field | Description |
|---|---|
| `outputLevel` | `extensions` (default) or `publishers` (one row per publisher per marketplace, with portfolio) |
| `marketplaces` | Any of `chrome`, `firefox`, `vscode`, `openvsx`, `jetbrains` (default when empty: the first four) |
| `searchTerms` | Keywords, e.g. `"ai code review"`, `"tailwind"`, `"password manager"` |
| `strictSearch` | Keep only results containing every keyword (default `true`) |
| `publishers` | VS Code publisher (`ms-python`), Open VSX namespace (`redhat`), Firefox author (`bitwarden`), JetBrains vendor (`JetBrains`, `Red Hat`). Not available on Chrome |
| `extensionIds` | Watchlist: `chrome:ddkjiahejlhfcafbddmgiahcphecmpfh`, `vscode:ms-python.python`, `openvsx:redhat.java`, `firefox:ublock-origin`, `jetbrains:17718` or `jetbrains:com.github.copilot`, or marketplace URLs |
| `vscodeCategory` / `firefoxCategory` | Category filter, e.g. `AI`, `Themes`, `Linters` / `privacy-security`, `tabs` |
| `jetbrainsTag` / `jetbrainsProduct` | JetBrains tag (`AI`, `Code Tools`, `Theme`, `Framework`) / IDE (`idea`, `pycharm`, `webstorm`, `goland`, `rider`, `phpstorm`, `clion`, `rubymine`, `androidstudio`) |
| `sortBy` | `installs`, `updated`, `newest`, `rating`, `relevance` |
| `maxResultsPerQuery` | Max results per query per marketplace (default 50) |
| `maxExtensionsPerPublisher` | Publishers mode: extensions loaded per publisher (default 100, most installed first) |
| `minInstalls` | Skip small extensions |
| `staleAfterDays` | Threshold for `isStale` (default 365) |
| `outputMode` | `all`, `new` (never seen before) or `changed` (new + any change) |
| `trackChanges` | Add change fields in `all` mode too |
| `minInstallsChangePct`, `minRankChange` | Thresholds for install and rank alerts |
| `stateKey` | Monitor name: use one per schedule |
| `includeMarketReport` | Also output one niche market-report row per marketplace × query |
| `marketReportOnly` | Output only the market-report rows (no extension rows) |
| `includeReviews` | Also output user reviews (Chrome, Firefox, VS Code, JetBrains) |
| `maxReviewsPerExtension` | Review rows per extension (default 50) |
| `reviewSort` | `recent` (default), `helpful`, `lowest` (Chrome; other stores return newest first) |
| `maxReviewRating` | e.g. `2` = only 1-2 star reviews |
| `includeReviewInsights` | One review-insights row per extension (complaint / praise themes, problem releases, trend) + a competitor comparison row |
| `reviewsSince` | `"2026-09-01"` or `"30 days"` |

If you give no search terms, publishers or IDs, the Actor lists the top extensions of each marketplace (or of the chosen category). Chrome Web Store doesn't support whole-store browsing or publisher lists; use search terms or extension IDs there. Chrome results follow the store's own relevance order.

Example: daily feed of brand-new AI extensions on VS Code and Open VSX:

```json
{
  "marketplaces": ["vscode", "openvsx"],
  "vscodeCategory": "AI",
  "sortBy": "newest",
  "maxResultsPerQuery": 100,
  "outputMode": "new",
  "stateKey": "new-ai-extensions"
}
```

Example: the most downloaded AI plugins for JetBrains IDEs, with a daily alert for new versions, download jumps and rank moves:

```json
{
  "marketplaces": ["jetbrains"],
  "jetbrainsTag": "AI",
  "maxResultsPerQuery": 100,
  "outputMode": "changed",
  "stateKey": "jetbrains-ai-plugins"
}
```

Example: the same keyword on VS Code and JetBrains IDEs (JetBrains side limited to PyCharm plugins):

```json
{
  "marketplaces": ["vscode", "jetbrains"],
  "searchTerms": ["tailwind"],
  "jetbrainsProduct": "pycharm",
  "maxResultsPerQuery": 50
}
```

Example: password managers on Chrome and Firefox with users, ratings and permissions:

```json
{
  "marketplaces": ["chrome", "firefox"],
  "searchTerms": ["password manager"],
  "maxResultsPerQuery": 100
}
```

Example: competitor watchlist with change alerts:

```json
{
  "extensionIds": ["https://chromewebstore.google.com/detail/grammarly-ai-writing-and-g/kbfnbcaeplbcioakkpcpgfkobkghlhen", "vscode:GitHub.copilot", "vscode:Codeium.codeium", "vscode:sourcery.sourcery", "openvsx:Codium.codium"],
  "outputMode": "changed",
  "minInstallsChangePct": 2,
  "stateKey": "competitors"
}
```

Example: who publishes Tailwind tooling on VS Code and Open VSX, with each publisher's whole portfolio and a weekly alert for new extensions:

```json
{
  "outputLevel": "publishers",
  "marketplaces": ["vscode", "openvsx"],
  "searchTerms": ["tailwind"],
  "maxResultsPerQuery": 30,
  "outputMode": "changed",
  "stateKey": "tailwind-publishers"
}
```

Example: every new 1-2 star review of your extension and two competitors, each morning:

```json
{
  "extensionIds": ["chrome:nngceckbapebfimnlniiiahkandclblb", "chrome:hdokiejnpimakedhajhdlcegeplioahd", "firefox:bitwarden-password-manager"],
  "includeReviews": true,
  "maxReviewRating": 2,
  "outputMode": "changed",
  "stateKey": "review-alerts"
}
```

### Output

```json
{
  "uid": "vscode:sourcery.sourcery",
  "source": "vscode",
  "id": "sourcery.sourcery",
  "name": "Sourcery",
  "publisher": "sourcery",
  "publisherVerified": true,
  "description": "Instant Code Reviews in your IDE",
  "url": "https://marketplace.visualstudio.com/items?itemName=sourcery.sourcery",
  "categories": ["Programming Languages", "Linters", "AI"],
  "tags": ["ai", "code review", "refactoring"],
  "version": "1.46.0",
  "installs": 1277242,
  "installsMetric": "installs",
  "rating": 4.28,
  "ratingCount": 43,
  "trendingWeekly": 0.373,
  "createdAt": "2020-02-25T12:59:30.28+00:00",
  "lastUpdated": "2026-09-17T14:33:34.537+00:00",
  "daysSinceUpdate": 17,
  "isStale": false,
  "repository": "https://github.com/sourcery-ai/sourcery-vscode.git",
  "pricing": "Free",
  "rank": 1,
  "query": "search:ai code review",
  "isNew": false,
  "previousVersion": "1.45.2",
  "previousInstalls": 1251000,
  "installsChange": 26242,
  "installsChangePct": 2.1,
  "previousRank": 2,
  "rankChange": 1,
  "changeTypes": ["new-version"],
  "scrapedAt": "2026-10-05T08:00:00.000Z"
}
```

Chrome Web Store records add:

```json
{
  "uid": "chrome:ddkjiahejlhfcafbddmgiahcphecmpfh",
  "name": "uBlock Origin Lite",
  "publisher": "Raymond Hill (gorhill)",
  "installs": 21000000,
  "installsMetric": "users",
  "rating": 4.5,
  "ratingCount": 3641,
  "version": "2026.930.1227",
  "lastUpdated": "2026-09-30T14:36:39.000Z",
  "categories": ["make_chrome_yours/privacy"],
  "manifestVersion": 3,
  "permissions": ["activeTab", "declarativeNetRequest", "scripting", "storage"],
  "hostPermissions": ["<all_urls>"],
  "sizeText": "9.2MiB",
  "privacyPolicyUrl": "https://github.com/gorhill/uBlock/wiki/Privacy-policy"
}
```

JetBrains Marketplace records (real row, October 2026, shortened):

```json
{
  "uid": "jetbrains:17718",
  "source": "jetbrains",
  "id": "17718",
  "pluginXmlId": "com.github.copilot",
  "name": "GitHub Copilot - Your AI Pair Programmer",
  "publisher": "GitHub",
  "publisherId": "GitHub",
  "publisherVerified": true,
  "url": "https://plugins.jetbrains.com/plugin/17718-github-copilot--your-ai-pair-programmer",
  "categories": ["AI", "Code Editing", "Code Tools", "Completion", "Productivity"],
  "tags": ["Externally-Paid", "AI", "Code Editing", "Code Tools", "Completion", "Productivity"],
  "version": "1.18.0-261-linux-arm64",
  "installs": 54778778,
  "installsMetric": "downloads",
  "rating": 2.28,
  "ratingCount": 1899,
  "lastUpdated": "2026-09-18T03:59:31.000Z",
  "homepage": "https://docs.github.com/en/copilot/getting-started-with-github-copilot/getting-started-with-github-copilot-in-a-jetbrains-ide",
  "supportUrl": "https://github.com/microsoft/copilot-intellij-feedback/issues",
  "ideFamily": "intellij",
  "pricing": "Free",
  "rank": 3
}
```

`categories` are the plugin's public tags; `tags` also include the marketplace's pricing tags (`Paid`, `Freemium`, `Externally-Paid`). `rating` is the average of all star votes and `ratingCount` the number of votes.

A publisher row (`outputLevel: "publishers"`, VS Code, October 2026, lists shortened):

```json
{
  "recordType": "publisher",
  "source": "vscode",
  "publisher": "Microsoft",
  "publisherId": "ms-python",
  "publisherVerified": true,
  "websiteDomain": "microsoft.com",
  "website": "https://microsoft.com",
  "domainVerified": true,
  "repositories": ["https://github.com/microsoft/pylance-release.git", "https://github.com/microsoft/vscode-black-formatter.git"],
  "extensionCount": 11,
  "portfolioComplete": true,
  "installsMetric": "installs",
  "totalInstalls": 699934972,
  "totalRatings": 1245,
  "averageRating": 3.42,
  "topExtension": { "id": "ms-python.python", "name": "Python", "installs": 239866117, "rating": 4.2, "ratingCount": 630 },
  "categories": ["Programming Languages", "Formatters", "Linters", "Data Science", "Debuggers"],
  "latestUpdate": "2026-10-06T10:51:02.507Z",
  "newestExtensionAt": "2024-12-10T19:22:05.393Z",
  "staleExtensions": 1,
  "matchedExtensions": ["Python"],
  "extensions": [{ "id": "ms-python.python", "name": "Python", "installs": 239866117, "rating": 4.2, "ratingCount": 630, "version": "2026.7.2026100201" }]
}
```

`websiteDomain` is the VS Code verified publisher domain when there is one, otherwise the most common domain of the extensions' homepage, support and privacy links. In monitor mode a publisher row adds `changeTypes`, `newExtensions`, `removedExtensions`, `totalInstallsChange(Pct)`, `previousExtensionCount` and `previousAverageRating`. Chrome extension rows now also carry Chrome's developer id in `publisherId`.

Review rows (`includeReviews: true`, real example):

```json
{
  "recordType": "review",
  "uid": "chrome:nngceckbapebfimnlniiiahkandclblb",
  "source": "chrome",
  "extensionName": "Bitwarden Password Manager",
  "reviewId": "83d2b9d5-a8a3-4364-b944-dae11d658617",
  "rating": 2,
  "text": "The latest update has a bug or something, because the auto-fill for Chrome isn't working.",
  "createdAt": "2026-10-01T20:43:29.000Z",
  "helpfulCount": 1,
  "reviewVersion": "2026.9.2",
  "language": "en",
  "developerReply": "Hey there, the team would need more information to look into what you're describing...",
  "developerReplyAt": "2026-10-01T20:47:08.000Z",
  "hasDeveloperReply": true
}
```

Extension rows have `recordType: "extension"`. `installsMetric` tells you what `installs` means on each marketplace: `users` (Chrome Web Store, as shown on the store, e.g. 8,000,000), `installs` (VS Code), `downloads` (Open VSX and JetBrains) or `dailyUsers` (Firefox average daily users; `weeklyDownloads` is also included). Change fields appear when `outputMode` is `new`/`changed` or `trackChanges` is on. A run summary is saved to the `SUMMARY` record in the key-value store.

No personal data is collected. Publisher names are the public display names shown on the marketplaces. Support emails are not exported, and review rows contain no reviewer names or profile pictures.

### Pricing

**$1.50 per 1,000 extensions** returned and **$0.50 per 1,000 reviews** (only when `includeReviews` is on). Publisher rows (`outputLevel: "publishers"`, portfolio included) cost **$5 per 1,000 publishers**. A niche **market report costs $0.02** per marketplace × query (with `marketReportOnly` the extensions analysed for it are not charged). No subscription.

A 50-extension snapshot of one keyword on four marketplaces costs about $0.30; the top 100 JetBrains plugins cost $0.15. In `changed` mode you pay only for the extensions that actually changed, so a daily competitor monitor usually costs cents per month. 1,000 Chrome reviews of one extension cost $0.50. Review insights cost **$0.01 per extension** (plus $0.01 for the comparison row); the reviews read for them are not charged.

### Niche market report

Input:

```json
{
  "marketplaces": ["chrome", "firefox", "vscode"],
  "searchTerms": ["tab manager"],
  "maxResultsPerQuery": 60,
  "marketReportOnly": true
}
```

Real Chrome Web Store row from our test (October 2026, shortened):

```json
{
  "recordType": "market-report",
  "source": "chrome",
  "query": "search:tab manager",
  "totalInStore": 780,
  "extensionsAnalyzed": 60,
  "installsMetric": "users",
  "totalInstalls": 2026441,
  "medianInstalls": 2000,
  "topExtensionInstallShare": 0.493,
  "top3InstallShare": 0.74,
  "ratingWeightedRating": 4.57,
  "updateFreshness": { "medianDaysSinceUpdate": 171, "updatedLast90Days": 0.333, "notUpdatedOver2Years": 0.15 },
  "newExtensionsLast365Days": 10,
  "permissionRiskMix": { "medium": 19, "high": 19, "low": 18, "critical": 4 },
  "allSitesAccessShare": 0.283,
  "manifestV2Extensions": 0,
  "weakIncumbents": [{ "name": "Tab Session Manager", "installs": 100000, "rating": 3.53 }],
  "staleIncumbents": [{ "name": "Tab Manager by Workona", "installs": 200000, "rating": 4.63 }],
  "risingNewcomers": [{ "name": "Tab Group Manager by Zovo", "installs": 2000, "rating": 4.85 }],
  "opportunitySignals": [
    "2 of the top 10 by users not updated for over a year",
    "1 large extension(s) rated below 3.8 (e.g. Tab Session Manager, 3.53★)",
    "3 extension(s) launched in the last 12 months already have traction"
  ]
}
```

The same run showed Firefox's tab-manager niche is dominated (one add-on holds 69% of daily users) with 6 of the top 10 not updated for a year, while VS Code has no real tab-manager leader at all. "Big" means 10,000+ users / installs / downloads (Firefox: 1,000+ daily users). Weak incumbents need 20+ ratings and a rating below 3.8; stale incumbents have no update for over 365 days; rising newcomers were created in the last 12 months and already have a tenth of the "big" bar. Every report is also saved in the `MARKET_REPORT` key-value record.

### Review insights: why users leave a competitor

Input (real run, October 2026):

```json
{
  "marketplaces": ["chrome", "firefox", "vscode"],
  "searchTerms": ["grammar checker"],
  "maxResultsPerQuery": 4,
  "includeReviewInsights": true,
  "maxReviewsPerExtension": 150
}
```

What came back from the newest 150 reviews per extension (shortened):

| Extension | Avg of newest reviews | Top complaint (1-3★ reviews) | Problem releases | Trend |
|---|---|---|---|---|
| LanguageTool (Firefox) | 1.25★ | paywall & pricing: 82 reviews | - | - |
| LanguageTool (Chrome) | 2.17★ | paywall & pricing: 71 reviews | - | improving |
| Grammarly (Firefox) | 2.83★ | bugs & errors / paywall: 24 each | 8.937.0 at 1.58★ (−1.35 vs other versions) | declining |
| Grammarly (Chrome) | 3.09★ | bugs & errors: 19, ads & pop-ups: 15 | 14.1330.0 at 2.0★ | declining |
| Harper (Firefox) | 3.89★ | bugs & errors: 6 | 2.8.0 | declining |
| LTeX+ (VS Code) | 4.75★ | - | - | - |

The `review-comparison` row then says, for example, that Harper gets far more *lightweight & fast* and *privacy-friendly* praise than its peers, while Grammarly on Chrome is weak in ads / pop-ups, performance and site conflicts. That is a positioning brief for a new grammar extension in one run.

Each insights row also has `topPraise`, `featureRequests` (with quotes), `topPhrases` (common 2-word phrases in 1-2★ reviews), `byVersion`, `byMonth`, `developerReplies` (reply rate, median hours to reply) and, on Chrome, `reviewLanguages`.

### Extension security monitor (permissions)

```json
{
  "marketplaces": ["chrome", "firefox"],
  "extensionIds": ["bmnlcjabgnpnenekpadlanbbkooimhnj", "kbfnbcaeplbcioakkpcpgfkobkghlhen", "firefox:darkreader"],
  "outputMode": "changed",
  "stateKey": "company-allowlist"
}
```

Schedule it daily. The first run is the baseline; later runs return only extensions that changed. Real rows from our tests (state edited to simulate a change):

```json
[
  { "source": "chrome", "name": "Honey: Automated Coupons & Rewards", "changeTypes": ["permissions-added"], "addedPermissions": ["cookies"], "permissionRiskLevel": "critical" },
  { "source": "firefox", "name": "Dark Reader", "changeTypes": ["risk-up"], "previousPermissionRiskLevel": "medium", "permissionRiskLevel": "high" },
  { "source": "chrome", "name": "The Great Suspender", "changeTypes": ["removed-from-store"], "availability": "unavailable", "lastSeenVersion": "7.1.6" }
]
```

Audit a category instead: `"searchTerms": ["vpn"], "minPermissionRisk": "high"` → in our test all 10 top Chrome VPN extensions scored **critical** (access to all websites + `proxy`, `webRequest`, `management`, `privacy`). A Chrome / Firefox row carries:

```json
{
  "name": "Grammarly: AI Writing Assistant and Grammar Checker App",
  "permissionRiskScore": 100,
  "permissionRiskLevel": "critical",
  "allSitesAccess": true,
  "hostPermissionCount": 98,
  "riskyPermissions": [
    { "permission": "http://*/*", "level": "critical", "reason": "can read and change data on all websites" },
    { "permission": "nativeMessaging", "level": "critical", "reason": "can talk to programs installed on the computer" },
    { "permission": "cookies", "level": "high", "reason": "can read and change cookies (session tokens)" },
    { "permission": "clipboardRead", "level": "high", "reason": "can read the clipboard" }
  ]
}
```

### Scheduling a monitor

1. Set `outputMode` to `changed` (or `new`) and give the monitor a `stateKey`.
2. Run it once. The first run is the baseline and returns everything.
3. Create an Apify Schedule (e.g. daily). Later runs return only what changed. Connect a webhook, Slack or email integration to get alerts.

### FAQ

**How do I research a browser extension or VS Code extension idea before building it?**
Set `marketReportOnly: true`, add your keyword ideas to `searchTerms` and pick the marketplaces. Each marketplace × keyword gives one market-report row: how many extensions exist, how concentrated the users are, how satisfied they are, whether the leaders are still maintained, and which newcomers broke through recently. Compare the rows side by side in the "Market reports" view.

**Does the market report use all extensions in the store?**
It uses the results of each query up to `maxResultsPerQuery` (sorted by installs by default, so the biggest extensions are always in), after `strictSearch`, `minInstalls` and `minPermissionRisk`. `totalInStore` shows how many results the store itself reports. Raise `maxResultsPerQuery` (up to 2,000) for a fuller picture of the long tail.

**How do I analyse a competitor's reviews without reading them all?**
Set `includeReviewInsights: true` and add the competitor's ID or URL to `extensionIds` (or search the niche). You get one row per extension with complaint themes and quotes, praise themes, feature requests, the rating trend and the versions users rated worst. Raise `maxReviewsPerExtension` (e.g. 300) for a bigger sample. You don't need `includeReviews` for it, and the reviews read for insights are not charged.

**How are the review themes detected? Is it AI?**
Rule-based keyword themes tuned for browser extensions and IDE plugins (same method as our App Store / Google Play review Actor), so results are repeatable and cheap. Complaint themes are counted in 1-3★ reviews, praise in 4-5★ reviews. Each theme comes with example quotes so you can check it. Non-English reviews are counted in the ratings and trend but mostly don't match the English themes.

**Does a high permission risk mean an extension is malicious?**
No. The score measures what the extension *can* do (its declared permissions), not what it does. Ad blockers, password managers and writing assistants need broad access and score high. Use it to decide what deserves a closer look, and use the monitor to catch *changes* (new permissions, takedowns), which are the stronger warning signs. VS Code, Open VSX and JetBrains have no permission model, so those rows have no risk fields.

**How is "removed from store" detected?**
For extensions you track by ID / URL in a monitor mode (`outputMode` "changed" / "all" with `trackChanges`), the Actor remembers each extension. If a later run finds the listing unavailable (Chrome's store returns an error status, Firefox / VS Code return 404), you get one `removed-from-store` row with the last known name, version and users. You are alerted once; if it comes back you get `back-in-store`.

**Can I scrape the Chrome Web Store with this?**
Yes. Search by keyword (all result pages, not just the first 10) or track exact extensions by ID or URL. You get users, rating, rating count, version, last update, developer, category, permissions and host permissions.

**How do I find an extension's Chrome ID?**
It's the 32-letter code at the end of its Chrome Web Store URL, e.g. `.../detail/ublock-origin-lite/ddkjiahejlhfcafbddmgiahcphecmpfh`. You can also paste the whole URL into `extensionIds`.

**Can I get alerts when a competitor ships a new version or gains users?**
Yes. Put the extensions in `extensionIds`, set `outputMode` to `changed` and schedule the run daily. You get `new-version`, `installs-up` / `installs-down`, `rating-change` and rank changes.

**Can I get one row per developer instead of per extension?** Yes: `outputLevel: "publishers"`. Each row is one publisher on one marketplace with `extensionCount`, `totalInstalls`, `totalRatings`, `averageRating`, `topExtension`, `websiteDomain`, `repositories` and the `extensions` list. `portfolioComplete` is `true` when the whole list was loaded (VS Code, Open VSX, Firefox, JetBrains); Chrome has no developer listing, so Chrome portfolios are search-based and marked `false`.

**Does it collect developer emails?**
No. Only public listing data is collected. Support emails and other personal contact data aren't exported.

**Can I scrape Chrome Web Store reviews?**
Yes. Set `includeReviews: true` and give search terms or extension IDs. You get the star rating, full text, date, extension version, helpful votes, language and the developer's reply. Sort by newest, most helpful or lowest rating, and page through thousands of reviews per extension.

**How do I get only negative reviews?**
Set `maxReviewRating` to `2` (or `1`). Combine with `reviewSort: "lowest"` on Chrome to reach the complaints first, or with `reviewsSince: "30 days"` for recent ones.

**Can I get new reviews every day without duplicates?**
Yes. Use `outputMode: "changed"` (or `new`) with a `stateKey` and schedule the Actor. Each run returns only reviews posted since the previous run. Extensions whose rating count did not change are not re-checked.

**Are VS Code and Firefox reviews included?**
Yes, both with developer replies. VS Code returns reviews that have text; Firefox returns written reviews (rating-only votes are skipped). Open VSX has almost no reviews and is skipped.

**Can I scrape JetBrains Marketplace plugins?**
Yes. Add `jetbrains` to `marketplaces`. Search by keyword, browse the whole marketplace sorted by downloads, rating, last update or newest, filter by tag (`jetbrainsTag`) or IDE (`jetbrainsProduct`), list every plugin of a vendor (`publishers`), or watch exact plugins by ID, XML id or plugins.jetbrains.com URL. Every row has downloads, rating, rating count, latest version, last update and vendor; change tracking and reviews work the same as on the other marketplaces.

**Are JetBrains plugin reviews included?**
Yes, with `includeReviews: true`: star rating (when the reviewer gave one), text, date, helpful votes, number of replies and the vendor's reply when the marketplace marks it as written by the vendor. Reviewer names are not collected.

**Does it work for Microsoft Edge add-ons?**
Not yet. Most Edge add-ons are also published on the Chrome Web Store.

### More tools from the same developer

- [GitHub Marketplace Apps & Actions Tracker](https://apify.com/signalscope-data/github-marketplace-tracker) — GitHub apps with exact installs, plans and permissions, plus Actions with stars and releases, and new-listing alerts.
- [Atlassian, Zoom & Zendesk Marketplace Apps Tracker](https://apify.com/signalscope-data/saas-marketplaces-tracker) — apps from three SaaS integration marketplaces in one schema: installs, ratings, pricing, versions and change alerts.
- [Salesforce AppExchange Scraper & Listing Monitor](https://apify.com/signalscope-data/appexchange-tracker) — AppExchange apps and agents with ratings, reviews, pricing and versions, plus new-listing and change alerts.
- [App Store & Google Play Top Charts & App Rank Tracker](https://apify.com/signalscope-data/app-charts-tracker) — top free/paid/grossing charts in any country, with daily rank changes and breakout apps.
- [App Store & Google Play Reviews Scraper](https://apify.com/signalscope-data/app-reviews-scraper) — reviews, ratings and new-review monitoring for any app.
- [Hacker News Who Is Hiring Scraper](https://apify.com/signalscope-data/hn-hiring-parser) — structured jobs from the monthly HN threads.
- [Company Jobs Scraper](https://apify.com/signalscope-data/ats-jobs-scraper) — every open job from Workday, Greenhouse, Lever, Ashby & more, with new-job alerts.
- [Telegram Channel Scraper & Keyword Monitor](https://apify.com/signalscope-data/telegram-channel-monitor) — public channel posts with keyword alerts.
- [Shopify Products Scraper & Price Change Monitor](https://apify.com/signalscope-data/shopify-store-monitor) — full catalogs plus price-drop / restock alerts.

# Actor input Schema

## `outputLevel` (type: `string`):

"publishers" groups the matching extensions by publisher and loads each publisher's portfolio on that marketplace (VS Code, Open VSX, Firefox and JetBrains: the full list by publisher; Chrome: found by searching the developer name, matched by developer id): extension count, total installs, total ratings, weighted average rating, top extension, website domain, GitHub repos, last update, stale extensions and the extensions list. In monitor modes alerts on new publishers, new / removed extensions, installs up/down and rating changes. Charged per publisher row; reviews are not collected in this mode.

## `marketplaces` (type: `array`):

Which marketplaces to query. Every search term / publisher is run on each selected marketplace. Chrome Web Store supports search terms and extension IDs (no publisher or whole-store browsing). JetBrains Marketplace covers plugins for IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, PhpStorm, CLion, Android Studio and other JetBrains IDEs. Default when left empty: the four browser / VS Code marketplaces.

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

Keywords to search, e.g. "ai assistant", "tailwind", "password manager". Leave empty to browse the top list (optionally within a category).

## `strictSearch` (type: `boolean`):

Keep only results whose name, ID, description, tags or categories contain every word of the search term. Marketplaces otherwise return loosely related popular extensions when sorting by installs.

## `publishers` (type: `array`):

List all extensions of these publishers: VS Code publisher ID (e.g. "ms-python"), Open VSX namespace (e.g. "redhat"), Firefox author username/ID (e.g. "bitwarden") or JetBrains Marketplace vendor (e.g. "JetBrains", "Red Hat"). Not available for Chrome Web Store.

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

Track exact extensions: "chrome:<32-letter ID>", "vscode:ms-python.python", "openvsx:redhat.java", "firefox:ublock-origin", "jetbrains:17718" (or the plugin's XML id, e.g. "jetbrains:com.github.copilot") or full marketplace URLs (Chrome Web Store and plugins.jetbrains.com URLs too). Without prefix, a 32-letter ID is Chrome, a number is JetBrains, "publisher.name" is looked up on VS Code + Open VSX and a plain slug on Firefox.

## `vscodeCategory` (type: `string`):

Optional category filter, e.g. "AI", "Programming Languages", "Themes", "Linters", "Debuggers", "Snippets", "Chat", "Formatters", "Testing", "Data Science".

## `firefoxCategory` (type: `string`):

Optional Firefox category slug, e.g. "privacy-security", "tabs", "search-tools", "download-management", "appearance", "other".

## `jetbrainsTag` (type: `string`):

Optional JetBrains Marketplace tag filter, e.g. "AI", "Code Tools", "Theme", "Framework", "Programming Language", "Tools Integration", "Productivity".

## `jetbrainsProduct` (type: `string`):

Optional: only plugins compatible with this JetBrains IDE, e.g. "idea" (IntelliJ IDEA), "pycharm", "webstorm", "goland", "rider", "phpstorm", "clion", "rubymine", "androidstudio", "dataspell".

## `sortBy` (type: `string`):

Ranking used for search and browse lists. The rank field and rank-change tracking follow this order. Chrome Web Store search is always ordered by the store's own relevance.

## `maxResultsPerQuery` (type: `integer`):

Max extensions per search term / publisher / category list per marketplace.

## `maxExtensionsPerPublisher` (type: `integer`):

Publishers mode only: load at most this many extensions per publisher (most installed first). portfolioComplete is false when the cap is hit (and always for Chrome, which has no developer listing).

## `minInstalls` (type: `integer`):

Skip extensions below this many installs (VS Code), downloads (Open VSX, JetBrains), users (Chrome) or daily users (Firefox).

## `minPermissionRisk` (type: `string`):

Output only Chrome / Firefox extensions whose permission risk is at least this level (VS Code, Open VSX and JetBrains have no permission model and are excluded when set). Every Chrome and Firefox row gets permissionRiskScore (0–100), permissionRiskLevel, allSitesAccess and riskyPermissions with a plain-English reason (e.g. cookies, webRequest, debugger, access to all websites).

## `staleAfterDays` (type: `integer`):

Extensions not updated for more than this many days get isStale = true (abandoned-extension finder).

## `outputMode` (type: `string`):

"new" and "changed" compare with the previous run of the same monitor name. The first run is the baseline and outputs everything.

## `trackChanges` (type: `boolean`):

Save a snapshot and add previousInstalls, installsChange, rankChange, previousVersion and changeTypes even when outputting all results.

## `minInstallsChangePct` (type: `integer`):

An installs-up / installs-down change is reported when installs moved at least this many percent since the last run.

## `minRankChange` (type: `integer`):

A rank-up / rank-down change is reported when the position moved at least this many places.

## `stateKey` (type: `string`):

Snapshot name used for change tracking. Use a different name for each separate monitor/schedule.

## `includeMarketReport` (type: `boolean`):

Also output one market-report row per marketplace × search term / publisher / category (recordType = "market-report"): total extensions in the store, installs (total, median, distribution), market concentration (top 1 / 3 / 10 install share), average and rating-weighted rating, rating distribution, pricing mix, update freshness, new extensions in the last 90 / 365 days, permission-risk mix and all-sites access share (Chrome, Firefox), Chrome extensions still on Manifest V2, top publishers, VS Code weekly trending, weak incumbents (big but rated below 3.8), stale incumbents (big but not updated for a year), rising newcomers and plain-English opportunity signals. With trackChanges or a monitor output mode it adds what changed since the last run. Uses the same filters (minInstalls, minPermissionRisk) and maxResultsPerQuery as the extension rows.

## `marketReportOnly` (type: `boolean`):

Output only the market-report rows (no extension, publisher or review rows). Use this to size a niche before building an extension. Each report is charged as one market-report event; extensions analysed for it are not charged.

## `includeReviewInsights` (type: `boolean`):

Also output one review-insights row per matched extension (recordType = "review-insights") from its newest reviews (up to "Max reviews per extension"): rating distribution, negative / positive share, rating trend (last 90 days vs older), top complaint themes in 1-3 star reviews (bugs, broke after update, browser / IDE compatibility incl. Manifest V3, performance & memory, breaks sites, ads & hijacking, privacy, paywall, login, sync & data loss, accuracy, UI, developer support) with example quotes, top praise themes in 4-5 star reviews, feature requests, common complaint phrases, rating by extension version with problem releases (a version rated 0.7+ stars below the others), monthly trend and developer reply rate / speed. With 2+ extensions of 10+ reviews a review-comparison row benchmarks them (themes per 100 reviews, relative weaknesses and strengths). Works on Chrome, Firefox, VS Code and JetBrains; works without "Include user reviews" (reviews read for insights are not charged).

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

Also output user reviews for every matched extension as separate rows (recordType = "review"): star rating, review text, date, extension version, helpful votes (Chrome) and the developer's reply. Works on Chrome Web Store, Firefox Add-ons, VS Code Marketplace and JetBrains Marketplace. Reviewer names are not collected. In "new"/"changed" output modes only reviews posted since the previous run are returned.

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

Upper limit of review rows per extension (after the star and date filters).

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

Order in which reviews are collected. "helpful" and "lowest" use the Chrome Web Store's own sort; Firefox, VS Code and JetBrains always return newest first.

## `maxReviewRating` (type: `integer`):

Keep only reviews with this many stars or fewer, e.g. 2 = complaints only (bug reports, churn reasons, feature requests). 5 = all reviews.

## `reviewsSince` (type: `string`):

Only reviews posted on or after this date ("2026-09-01") or within a period ("30 days", "2 weeks", "3 months").

## Actor input object example

```json
{
  "outputLevel": "extensions",
  "marketplaces": [
    "chrome",
    "vscode",
    "openvsx",
    "firefox",
    "jetbrains"
  ],
  "searchTerms": [
    "ai writing assistant"
  ],
  "strictSearch": true,
  "sortBy": "installs",
  "maxResultsPerQuery": 50,
  "maxExtensionsPerPublisher": 100,
  "minInstalls": 0,
  "minPermissionRisk": "",
  "staleAfterDays": 365,
  "outputMode": "all",
  "trackChanges": false,
  "minInstallsChangePct": 10,
  "minRankChange": 5,
  "stateKey": "default",
  "includeMarketReport": false,
  "marketReportOnly": false,
  "includeReviewInsights": false,
  "includeReviews": false,
  "maxReviewsPerExtension": 50,
  "reviewSort": "recent",
  "maxReviewRating": 5
}
```

# Actor output Schema

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

No description

# 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 = {
    "marketplaces": [
        "chrome",
        "vscode",
        "openvsx",
        "firefox",
        "jetbrains"
    ],
    "searchTerms": [
        "ai writing assistant"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalscope-data/extension-marketplaces-tracker").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 = {
    "marketplaces": [
        "chrome",
        "vscode",
        "openvsx",
        "firefox",
        "jetbrains",
    ],
    "searchTerms": ["ai writing assistant"],
}

# Run the Actor and wait for it to finish
run = client.actor("signalscope-data/extension-marketplaces-tracker").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 '{
  "marketplaces": [
    "chrome",
    "vscode",
    "openvsx",
    "firefox",
    "jetbrains"
  ],
  "searchTerms": [
    "ai writing assistant"
  ]
}' |
apify call signalscope-data/extension-marketplaces-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,signalscope-data/extension-marketplaces-tracker"
        }
    }
}
```

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/hUnORnoduJbMirFxL/builds/L6dCWCVv8lpBltoSF/openapi.json