# Chrome Web Store Extensions Scraper (`succinct_glider/chrome-web-store-extensions`) Actor

Scrape Chrome Web Store extensions: users, precise rating, rating count, version, update date, category, size and manifest permissions. Fast HTTP, no browser, no login.

- **URL**: https://apify.com/succinct\_glider/chrome-web-store-extensions.md
- **Developed by:** [Alexandre Bobichon](https://apify.com/succinct_glider) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.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?

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

### What does Chrome Web Store Extensions Scraper do?

**Chrome Web Store Extensions Scraper** extracts public data from [Chrome Web Store](https://chromewebstore.google.com/) extension pages: **user count, precise rating, number of ratings, category, version, last update date, size, languages, Featured badge, website, support and privacy policy links, the full list of permissions declared in the extension manifest and a permission risk level**.

Paste Chrome extension IDs or store URLs, or **discover the top extensions of any store category** filtered by users, rating, keyword or permission risk, click **Start**, and download clean, structured data in JSON, CSV or Excel. It runs on the Apify platform, so you also get API access, scheduling, integrations (Google Sheets, Zapier, Make, webhooks) and run monitoring.

It is a lightweight HTTP scraper: **no browser, no login, no proxy required**, and it scrapes **up to about 120 extensions per minute**.

### Why use Chrome Web Store Extensions Scraper?

- **Competitor tracking**: schedule a run with **change tracking** and get only what changed since last time: new versions, user and rating moves, new permissions. Unchanged extensions can be skipped, so you do not pay for them.
- **Security and permission audits**: get a **permission risk level** (`low`, `medium`, `high`) for each extension, see at a glance which ones can access **all websites** and which request **sensitive permissions** such as `cookies`, `tabs` or `webRequest`, with the full list of required, optional and host permissions.
- **Market research**: discover the top extensions of a store category (e.g. Developer Tools with at least 1,000,000 users) and compare them by adoption, rating, package size and update activity. With change tracking, get the extensions that newly entered the top.
- **Listing monitoring for extension developers**: check your own listing (version, update date, Featured badge, rating trend) without opening the store.

### How to scrape Chrome Web Store extension data

1. Open the **Input** tab.
2. Add extension IDs or Chrome Web Store URLs, one per line.
3. Optionally set **Max extensions** and disable **Include full description** for lighter results.
4. Click **Start**. The run status shows the progress, e.g. `Scraped 42 of 100 extensions…`.
5. Open the **Output** tab to view or download the results, and the **Run summary** to see which extensions were skipped.

#### Ready-to-use inputs

Copy one of these into the **JSON** view of the Input tab and replace the extensions with your own.

**Get only what changed at your competitors** (add a daily or weekly schedule; each run returns only new and changed extensions, with the previous values):

```json
{
    "extensions": ["eimadpbcbfnmbkopoojfekhnkhdbieeh", "aapbdbdomjkkjkaonfhkkikfgjllcleb"],
    "includeDescription": false,
    "onlyChanges": true
}
```

**Audit the permissions of the extensions installed in your company** (open the **Permissions** view of the Output tab and sort by risk level):

```json
{
    "extensions": [
        "https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh",
        "kbfnbcaeplbcioakkpcpgfkobkghlhen",
        "gppongmhjkpfnbhagpmjfkannfbllamg"
    ],
    "includeDescription": false
}
```

**Discover the top Developer Tools with at least 1,000,000 users and no high permission risk**:

```json
{
    "mode": "categories",
    "categories": ["productivity/developer"],
    "minUsers": 1000000,
    "maxPermissionRiskLevel": "medium",
    "includeDescription": false
}
```

**Market research on a list of extensions** (full descriptions included):

```json
{
    "extensions": ["ddkjiahejlhfcafbddmgiahcphecmpfh", "bcjindcccaagfpapjjmafapmmgkkhgoa"],
    "maxItems": 1000,
    "includeDescription": true
}
```

### Input

| Field | Description |
|---|---|
| `mode` | `extensions` (default): scrape your list. `categories`: discover the top extensions of store categories. |
| `categories` | With `mode: "categories"`, store categories to scan, e.g. `productivity/developer`, `lifestyle/games`, `make_chrome_yours/privacy` (18 available in the Input tab). Each category page lists its **top 32 extensions**. |
| `minUsers` / `minRating` / `keyword` / `maxPermissionRiskLevel` | With `mode: "categories"`, filters applied to the category listing **before** any extension page is read, so you only pay for matching extensions. `keyword` matches the name or short description; `maxPermissionRiskLevel` is `low`, `medium` or `high` (default, no filter). |
| `extensions` | With `mode: "extensions"`. Extension IDs, e.g. `eimadpbcbfnmbkopoojfekhnkhdbieeh`, or detail page URLs, e.g. `https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh`. Legacy `https://chrome.google.com/webstore/detail/...` URLs work too. |
| `maxItems` | Maximum number of extensions to scrape. Default `100`, from 1 to 5,000. Extra entries are ignored. |
| `includeDescription` | Include the full store description. Default `true`. |
| `trackChanges` | Compare each extension with its state from the previous tracked run (see [Change tracking](#change-tracking)). Default `false`. |
| `onlyChanges` | Save only new and changed extensions; unchanged ones are not saved and not charged. Enables change tracking. Default `false`. |
| `stateStoreName` | Key-value store of your account that keeps the previous state. Use one name per independent list. Default `chrome-web-store-extensions-state`. |
| `proxyConfiguration` | Optional, not needed by default. If you use a proxy, avoid EU locations: Google redirects them to a cookie consent page. |

Example input:

```json
{
    "extensions": [
        "https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh",
        "aapbdbdomjkkjkaonfhkkikfgjllcleb"
    ],
    "maxItems": 100,
    "includeDescription": false
}
```

### Output

Each extension becomes one item in the dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. The **Overview** and **Permissions** views of the Output tab show the most useful columns.

Example item (real data, `languages` and image URLs shortened):

```json
{
    "id": "eimadpbcbfnmbkopoojfekhnkhdbieeh",
    "name": "Dark Reader",
    "url": "https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh",
    "shortDescription": "Dark mode for every website. Take care of your eyes, use dark theme for night and daily browsing.",
    "description": null,
    "category": "make_chrome_yours/accessibility",
    "categoryName": "Accessibility",
    "users": 7000000,
    "rating": 4.656276071293136,
    "ratingCount": 13185,
    "version": "4.9.130",
    "updatedAt": "2026-09-02T11:25:59.000Z",
    "size": "828KiB",
    "sizeBytes": 847872,
    "languages": ["Deutsch", "English", "English (United Kingdom)", "français", "日本語"],
    "featured": true,
    "trader": true,
    "websiteUrl": "https://darkreader.org/",
    "supportUrl": null,
    "privacyPolicyUrl": "https://darkreader.org/privacy/",
    "minChromeVersion": "106.0.0.0",
    "manifestVersion": 3,
    "permissions": ["alarms", "fontSettings", "scripting", "storage"],
    "optionalPermissions": ["contextMenus"],
    "hostPermissions": ["*://*/*"],
    "allSitesAccess": true,
    "sensitivePermissions": [],
    "permissionRiskLevel": "medium",
    "iconUrl": "https://lh3.googleusercontent.com/T66wTLk-…",
    "screenshotUrls": ["https://lh3.googleusercontent.com/2_eQJ8fW…"],
    "videoUrls": ["https://www.youtube.com/embed/849mznBKmIQ?rel=0&wmode=opaque&enablejsapi=1"],
    "scrapedAt": "2026-09-14T17:20:12.327Z"
}
```

#### Run summary

At the end of each run, a `SUMMARY` record is saved in the default key-value store (the **Run summary** link in the Output tab), so you know what is missing without reading the log:

```json
{
    "requestedCount": 3,
    "scrapedCount": 2,
    "notFoundIds": ["abcdefghijklmnopabcdefghijklmnop"],
    "unreadableIds": [],
    "failedIds": [],
    "invalidInputs": ["https://example.com/not-an-extension"],
    "budgetReached": false,
    "missingKeyFields": { "version": 0, "updatedAt": 0 },
    "changes": { "new": 0, "changed": 1, "unchanged": 1 }
}
```

| Field | Description |
|---|---|
| `requestedCount` / `scrapedCount` | Extensions requested (after removing duplicates and applying `maxItems`) and extensions saved to the dataset. |
| `notFoundIds` | Removed or unlisted extensions (page not found, or store page without the extension). |
| `unreadableIds` | Extension pages without readable data: the store page layout may have changed. Please report it in the **Issues** tab. |
| `failedIds` | Extensions that still failed after retries (network errors, blocking). |
| `invalidInputs` | Input entries that are not extension IDs or Chrome Web Store detail URLs (first 100). |
| `budgetReached` | `true` when the run stopped early because your maximum cost per run was reached. |
| `missingKeyFields` | Number of scraped extensions without `version` or `updatedAt`. These fields exist on every listing, so high counts mean the store page layout changed. |
| `changes` | With change tracking, number of `new`, `changed` and `unchanged` extensions; `null` otherwise. |
| `discovery` | With `mode: "categories"`: requested categories, categories scanned, unreadable categories, extensions listed and extensions matching the filters; `null` otherwise. `invalidInputs` then lists unknown categories. |

#### Change tracking

Enable **Track changes** (or **Only save new and changed extensions**) and schedule the run. Each extension is compared with its state from the previous tracked run, saved in a key-value store of your account (`stateStoreName`):

- `new`: first time this extension is tracked in this store.
- `changed`: at least one of these fields changed: `name`, `categoryName`, `users`, `rating`, `ratingCount`, `version`, `updatedAt`, `size`, `featured`, `permissions`, `optionalPermissions`, `hostPermissions`, `allSitesAccess`, `permissionRiskLevel`.
- `unchanged`: none of them changed. With **Only save new and changed extensions**, these are not saved to the dataset and not charged.

The precise rating moves slightly all the time, so changes below 0.01 are ignored; a slow drift is still reported once it adds up. The **Changes** view of the Output tab shows the status, the changed fields and their previous values:

```json
{
    "name": "Dark Reader",
    "version": "4.9.131",
    "users": 7000000,
    "changeStatus": "changed",
    "changedFields": ["version", "updatedAt"],
    "previousValues": { "version": "4.9.130", "updatedAt": "2026-09-02T11:25:59.000Z" },
    "previousScrapedAt": "2026-09-08T06:00:12.000Z"
}
```

### Data fields

Every item has the same fields. Missing values are `null` (or an empty array for lists), never omitted.

| Field | Description |
|---|---|
| `id` / `name` / `url` | Extension ID, name and store detail URL. |
| `shortDescription` / `description` | Summary and full store description (`description` is `null` when **Include full description** is off). |
| `category` | Store category path, e.g. `productivity/developer` or `make_chrome_yours/accessibility`. |
| `categoryName` | Category label as displayed by the store, e.g. `Developer Tools`, `Privacy & Security` or `Accessibility`. |
| `users` | User count as displayed by the store (rounded by Google, e.g. `7000000`). |
| `rating` / `ratingCount` | Precise average rating (not rounded to one decimal) and number of ratings. |
| `version` / `updatedAt` | Current version and last update date (ISO 8601). |
| `size` / `sizeBytes` | Package size as shown by the store (e.g. `828KiB`) and the same size converted to bytes (e.g. `847872`), handy for sorting. `sizeBytes` is approximate because the store rounds the displayed size. |
| `languages` | Languages supported by the listing. |
| `featured` | `true` when the extension has the Featured badge. |
| `trader` | EU trader status declared by the developer: `true` (Trader), `false` (Non-trader), `null` when not shown. |
| `websiteUrl` / `supportUrl` / `privacyPolicyUrl` | Public links provided by the developer (e.g. `https://support.grammarly.com/`), `null` when the developer did not provide one. |
| `minChromeVersion` / `manifestVersion` | Minimum Chrome version and manifest version (2 or 3). |
| `permissions` / `optionalPermissions` / `hostPermissions` | Permissions from the extension manifest. Host patterns (such as `*://*/*` or `<all_urls>`) are always in `hostPermissions`, including for Manifest V2 extensions. |
| `allSitesAccess` | `true` when the extension can run on every website, through its host permissions or its content scripts (e.g. `<all_urls>`, `*://*/*`). `null` when the manifest cannot be read. |
| `sensitivePermissions` | Required permissions that reach beyond the visited page: browsing data (`cookies`, `history`, `tabs`, `bookmarks`…), network traffic (`webRequest`, `proxy`…), other apps and browser control (`nativeMessaging`, `debugger`, `management`…). Optional permissions are not included because they are not granted at install. |
| `permissionRiskLevel` | `high` = all sites access **and** sensitive permissions, `medium` = one of the two, `low` = neither, `null` when the manifest cannot be read. It reflects what the extension is **allowed** to do, not what it actually does. |
| `changeStatus` / `changedFields` / `previousValues` / `previousScrapedAt` | With change tracking: `new`, `changed` or `unchanged`, the list of changed fields, their previous values and the date of the previous tracked run. `null` when change tracking is off. |
| `iconUrl` / `screenshotUrls` / `videoUrls` | Store icon, gallery screenshots and YouTube promotional videos. |
| `scrapedAt` | Date and time of extraction (ISO 8601). |

### How much does it cost to scrape the Chrome Web Store?

The scraper sends plain HTTP requests and reads the data embedded in each page, without a browser and without building the page structure, so runs are **fast and light**. It runs with **512 MB of memory by default**. See the **Pricing** tab for the current price.

Removed, unlisted or unreadable extensions produce no item in the dataset. If you set a **maximum cost per run**, the Actor stops the crawl as soon as that limit is reached.

### Tips

- **Track trends**: schedule a daily or weekly run on the same list with **Track changes** on, and send the results to Google Sheets to build a history. Use **Only save new and changed extensions** to receive only the updates.
- **Reliable monitoring**: the run **fails** only when the scraper itself is in trouble, so schedules, webhooks and integrations can alert you: no extension could be read (blocking, network errors, unreadable pages), or `version` or `updatedAt` is missing on more than half of the extensions (store layout change). Small extensions without a displayed user count never fail the run. Problems on your side do not fail the run: an input without any valid extension, extensions that were all removed, or a stop at your maximum cost per run end with a clear status message and the run summary.
- **Check what was skipped**: open the **Run summary** (`SUMMARY` record) to get the IDs of removed, unreadable or failed extensions and the invalid input entries.
- **Lighter results**: disable **Include full description** when you only need metrics.
- **Tested at scale**: on 500 random extensions from the store sitemap, 487 were scraped and the 13 removed ones were reported as not found, with 0 failed requests, in about 4.5 minutes and 220 MB of memory. Of the 487 extensions, 11 % had a `high` permission risk level, 28 % `medium` and 61 % `low`.
- **No duplicates**: duplicate IDs, or different URLs pointing to the same extension, are scraped only once.
- **Speed**: to stay gentle with the store, the Actor processes up to about 120 extensions per minute (5 in parallel), so a run of 5,000 extensions (the maximum) takes around 40 minutes or more.
- **Memory**: keep the default 512 MB, which is also the minimum (a 500-extension run peaks at about 220 MB). More memory does not make the scraper faster, because the speed is capped.
- Entries that are not extension IDs or Chrome Web Store detail URLs are skipped with a warning in the log. URLs from other websites are rejected.

### FAQ, disclaimers and support

**Is it legal to scrape the Chrome Web Store?** This Actor only reads public extension detail pages that are allowed by the store's robots.txt. It does **not** collect reviews or any personal data: developer emails, phone numbers, postal addresses and personal names are deliberately excluded. You are responsible for using the data in compliance with applicable laws and Google's terms.

**Can it search the store or scrape a whole category?** It discovers the **top 32 extensions** of each of the 18 store categories, as listed on the public category pages, and filters them. Keyword search of the whole store and complete category listings are not supported.

**Why did my run fail?** Either no extension could be scraped (for example, requests were blocked or an EU proxy triggered Google's consent page), or the data quality check found key fields missing on most extensions, which means the store page layout changed and the scraper needs an update. The final status message explains what happened, and the `SUMMARY` record lists the affected extensions. Please report layout changes in the **Issues** tab.

**My run succeeded but the dataset is empty. Why?** The input contained no valid extension ID or URL, or all requested extensions were removed from the store. The status message and the `SUMMARY` record (`invalidInputs`, `notFoundIds`) tell you which.

**Can I use it with AI agents?** Yes. The Actor runs with limited permissions, so AI assistants connected to the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) (Claude, Cursor and others) can find it in Apify Store and call it on demand, for example to check the permissions of an extension before installing it.

**Known limitations**

- Reviews, search results and related extensions are not supported.
- Category discovery is limited to the top 32 extensions of each category page (576 extensions across the 18 categories). Filters use the values shown on the category page, which match the extension page.
- Removed or unlisted extensions are skipped with a warning and listed in the run summary.
- If an extension's manifest cannot be read, `manifestVersion` is `null` and the permission lists are empty.
- `sizeBytes` is derived from the rounded size displayed by the store, not from the actual package.
- The data comes from the store page structure, which Google can change without notice.

Found a bug or need an extra field? Open an issue in the **Issues** tab. Need a custom Chrome Web Store dataset? Get in touch through the Issues tab as well.

# Actor input Schema

## `mode` (type: `string`):

Scrape the extensions of your list, or discover the top extensions of Chrome Web Store categories.

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

Used with "Extensions from my list". Extension IDs (32 letters) or Chrome Web Store detail URLs, one per line. Example: https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh

## `categories` (type: `array`):

Used with "Top extensions of store categories". Each category page lists its top 32 extensions; the filters below are applied before any extension page is read.

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

Keep only listed extensions with at least this many users.

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

Keep only listed extensions rated at least this much (0 to 5).

## `keyword` (type: `string`):

Keep only listed extensions whose name or short description contains this text (case-insensitive).

## `maxPermissionRiskLevel` (type: `string`):

Keep only listed extensions up to this permission risk level.

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

Maximum number of extensions to scrape. Extra entries are ignored.

## `includeDescription` (type: `boolean`):

Include the full store description. Disable it to get smaller results.

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

Compare each extension with its state from the previous tracked run and add changeStatus (new, changed, unchanged), changedFields and previousValues to the results. Ideal with a schedule. The state is kept in a key-value store of your Apify account.

## `onlyChanges` (type: `boolean`):

Skip unchanged extensions: they are not saved to the dataset, so you are not charged for them. Enables change tracking automatically.

## `stateStoreName` (type: `string`):

Name of the key-value store that keeps the previous state. Use a different name for each independent list you track. Letters, digits and hyphens only.

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

Optional, not needed by default. Avoid proxies located in the EU: Google redirects them to a cookie consent page.

## Actor input object example

```json
{
  "mode": "extensions",
  "extensions": [
    "https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh",
    "aapbdbdomjkkjkaonfhkkikfgjllcleb"
  ],
  "categories": [
    "productivity/developer"
  ],
  "minUsers": 0,
  "minRating": 0,
  "maxPermissionRiskLevel": "high",
  "maxItems": 100,
  "includeDescription": true,
  "trackChanges": false,
  "onlyChanges": false,
  "stateStoreName": "chrome-web-store-extensions-state",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "extensions": [
        "https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh",
        "aapbdbdomjkkjkaonfhkkikfgjllcleb"
    ],
    "categories": [
        "productivity/developer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("succinct_glider/chrome-web-store-extensions").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "extensions": [
        "https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh",
        "aapbdbdomjkkjkaonfhkkikfgjllcleb",
    ],
    "categories": ["productivity/developer"],
}

# Run the Actor and wait for it to finish
run = client.actor("succinct_glider/chrome-web-store-extensions").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "extensions": [
    "https://chromewebstore.google.com/detail/dark-reader/eimadpbcbfnmbkopoojfekhnkhdbieeh",
    "aapbdbdomjkkjkaonfhkkikfgjllcleb"
  ],
  "categories": [
    "productivity/developer"
  ]
}' |
apify call succinct_glider/chrome-web-store-extensions --silent --output-dataset

```

## MCP server setup

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

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/EcIdg6VQuYKsa9OVa/builds/Izo7s6Wfxg5rEehBK/openapi.json