# Chrome Web Store Scraper — Extensions & Developer Leads (`scrapesage/chrome-web-store-scraper`) Actor

Scrape Chrome Web Store extensions: search by keyword or pull full details by URL/ID. Returns ratings, install counts, version, size, permissions, manifest, screenshots and developer contacts (email, website, address) as B2B leads. Monitoring mode for new extensions. No browser, no login.

- **URL**: https://apify.com/scrapesage/chrome-web-store-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 extension scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Web Store Scraper — Extensions, Ratings & Developer Leads

Extract **complete Chrome Web Store extension data** — ratings, install counts, version, size, full description, screenshots, **requested permissions**, the parsed **manifest**, and the **developer's contact details** (email, website, postal address) — straight from the store, with the **richest dataset in the category**. Search by keyword or pull specific extensions by URL/ID. Optionally turn every developer into a **ready-to-contact B2B lead** by crawling their own website for extra emails, phone numbers, and social links.

No login, no cookies, no browser — fast HTTP extraction with a clean, server-rendered data path.

### Why this Chrome Web Store scraper?

Most extension scrapers return the basics and stop there. This actor parses the store's embedded data record and ships the fields that actually matter for **lead generation, competitive intelligence, and security/permission review** — in one run:

| Data | Typical scrapers | This actor |
|---|---|---|
| Name, rating, rating count, install count | ✅ | ✅ |
| Version, size, last-updated & first-published dates | partial | ✅ |
| Full description + screenshots | partial | ✅ |
| **Developer email** (publisher contact) | ❌ | ✅ |
| **Developer website + postal address + legal name** | ❌ | ✅ |
| Requested **permissions / host permissions / optional permissions** | ❌ | ✅ |
| Parsed **manifest** (manifest version, content-script count) | ❌ | ✅ |
| Developer phone & socials (from their website) | ❌ | ✅ opt-in |
| **Lead score (0–100)** per extension | ❌ | ✅ |
| Monitoring mode — only new extensions | ❌ | ✅ |
| Start fee | $0.005–0.25 | **none** |

### Use cases

- **Lead generation** — extension developers are active SaaS buyers and partners. Every record carries the publisher's `developerEmail`, `developerWebsite` and `developerAddress`, scored by reach (`userCount`) and quality (`rating`). Filter by `leadScore` and reach the maker directly.
- **Competitive & market intelligence** — map a category or keyword: who's winning, install counts, ratings, update cadence (`lastUpdated`), and which permissions competitors request.
- **App-store optimization (ASO)** — track your and rivals' ratings, rating counts, descriptions, screenshots and versions over time.
- **Security & permission review** — audit the `permissions`, `hostPermissions` and `manifestVersion` of any extension or set of extensions for risk assessment, SOC 2 / vendor reviews, and supply-chain monitoring.
- **Portfolio & change monitoring** — schedule recurring runs to watch a keyword or a list of extensions for new entrants, version bumps and rating shifts.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Chrome Web Store Scraper**, choose a mode, enter search queries or extension URLs/IDs, and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "search",
    "searchQueries": ["screenshot", "ad blocker", "crm"],
    "maxResultsPerQuery": 30,
    "includeDeveloperContacts": true,
    "includePermissions": true,
    "enrichDeveloperContacts": true
}
````

Or pull specific extensions:

```json
{
    "mode": "extensionDetails",
    "extensionUrls": [
        "https://chromewebstore.google.com/detail/grammarly/kbfnbcaeplbcioakkpcpgfkobkghlhen",
        "cjpalhdlnbpafiamejdnhcphjbkeiagm"
    ],
    "enrichDeveloperContacts": true
}
```

- **mode** — `search` (discover by keyword) or `extensionDetails` (specific extensions).
- **searchQueries** — keywords to search; each result is enriched to the full record. (Mode: Search.)
- **extensionUrls** — Chrome Web Store URLs or bare 32-character extension IDs. (Mode: Extension details.)
- **startUrls** — paste any mix of detail URLs and `/search/<query>` URLs; each is auto-routed.
- **maxResultsPerQuery** *(default 30)* — cap per query. The store returns a curated short list per query (~10), so use several specific queries for breadth.
- **includeDeveloperContacts** *(default true)* — email, website, address, support URL, privacy policy + lead score.
- **includePermissions** *(default true)* — permissions, host/optional permissions, content-script count, manifest version.
- **includeScreenshots** *(default true)* — store screenshot image URLs.
- **enrichDeveloperContacts** *(default false)* — crawl the developer's own website (home + contact/about, max 3 pages) for extra emails, phone and socials.
- **deduplicateExtensions** *(default true)* — emit each extension at most once per run.
- **monitorMode** *(default false)* — emit only extensions not seen in previous runs (pairs with Schedules).

### Output

One record per extension (`type: "extension"`):

```json
{
    "type": "extension",
    "extensionId": "kbfnbcaeplbcioakkpcpgfkobkghlhen",
    "name": "Grammarly: AI Writing Assistant and Grammar Checker App",
    "url": "https://chromewebstore.google.com/detail/grammarly-ai-writing-assi/kbfnbcaeplbcioakkpcpgfkobkghlhen",
    "iconUrl": "https://lh3.googleusercontent.com/...",
    "summary": "Grammarly for Chrome helps you write with confidence.",
    "description": "Grammarly for Chrome is your always-on AI partner…",
    "rating": 4.498,
    "ratingCount": 43084,
    "userCount": 38000000,
    "category": "Communication",
    "categorySlug": "communication",
    "version": "14.1302.0",
    "lastUpdated": "2026-06-12T19:55:51.000Z",
    "published": "2012-03-22T07:34:57.000Z",
    "size": "43.58MiB",
    "sizeBytes": 45696942,
    "languages": ["English"],
    "manifestVersion": 3,
    "permissions": ["scripting", "sidePanel", "tabs", "notifications", "cookies", "identity", "storage"],
    "hostPermissions": ["http://*/*", "https://*/*"],
    "optionalPermissions": [],
    "contentScriptsCount": 8,
    "screenshots": ["https://lh3.googleusercontent.com/..."],
    "developerName": "Grammarly",
    "developerLegalName": "Grammarly, Inc.",
    "developerEmail": "support@grammarly.com",
    "developerWebsite": "http://grammarly.com/",
    "developerAddress": "548 Market St Ste 35410\nSan Francisco, CA 94104-5401\nUS",
    "developerSupportUrl": "https://support.grammarly.com/",
    "privacyPolicyUrl": "https://www.grammarly.com/privacy-policy",
    "contactEmails": ["pr@grammarly.com"],
    "contactPhones": [],
    "contactSocials": { "linkedin": "https://www.linkedin.com/company/grammarly", "twitter": "https://twitter.com/grammarly" },
    "leadScore": 100,
    "source": "extensionDetails",
    "scrapedAt": "2026-06-15T08:00:00.000Z"
}
```

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily/weekly to monitor new extensions for a keyword, or version/rating changes for a watchlist; perfect for lead pipelines and market dashboards.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/chrome-web-store-scraper').call({
    mode: 'search',
    searchQueries: ['crm', 'email finder'],
    enrichDeveloperContacts: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} extensions & developer leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new developer leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored keyword finds new extensions.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the top CRM extensions and list their developers' emails" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **app-market & developer-lead stack** across every store:

- **[Google Play Store Scraper](https://apify.com/scrapesage/google-play-scraper)** — Android apps, reviews & developer leads.
- **[Apple App Store Scraper](https://apify.com/scrapesage/app-store-scraper)** — iOS apps, reviews & charts.
- **[Steam Scraper](https://apify.com/scrapesage/steam-scraper)** — games, prices, reviews & charts.
- **[Shopify App Store Scraper](https://apify.com/scrapesage/shopify-app-store-scraper)** — Shopify apps, reviews & developer leads.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** — launches, makers & leads.
- **[Y Combinator Scraper](https://apify.com/scrapesage/ycombinator-scraper)** — startups, founders & jobs.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — channels, videos & creator leads.
- **[Substack Scraper](https://apify.com/scrapesage/substack-scraper)** — newsletters, posts & creator leads.

### Tips

- **Breadth**: the Chrome Web Store's search returns a focused, relevance-ranked short list per query (≈10). To cover a whole niche, run several specific queries (e.g. `screenshot`, `screen recorder`, `screen capture`) rather than one broad term.
- **Leads**: every extension already carries the developer's contact email and website from the store page — turn on `enrichDeveloperContacts` to add phone numbers and social profiles from the developer's own site.
- **Monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to capture only newly published or newly ranking extensions each run.
- **Cost control**: enrichment only runs for extensions that expose a developer website, and each extension is emitted once per run.

### FAQ

**How do I scrape a specific Chrome extension?** Use `extensionDetails` mode and paste the Chrome Web Store URL or the 32-character extension ID into `extensionUrls`.

**Does it need the Chrome Web Store API or a login?** No. There is no public Chrome Web Store API — this actor extracts the same data the store renders into its public pages, with no key or login.

**Where do the developer emails come from?** The Chrome Web Store publishes each developer's contact email, website and (for registered traders) postal address on the listing — this actor reads them directly. With `enrichDeveloperContacts` on, it also visits the developer's own website for extra emails, phone and socials.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new extensions automatically?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules); optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) to push new developer leads into your CRM as they appear.

**A field is null — why?** Some extensions genuinely don't set a developer website, address, or language list. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

**Is scraping the Chrome Web Store legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and Google's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

`Search` discovers extensions by keyword and pulls the full record for each result. `Extension details` pulls the full record (incl. developer leads & permissions) for specific extensions by URL or ID.

## `searchQueries` (type: `array`):

Keywords to search the Chrome Web Store for, e.g. `screenshot`, `ad blocker`, `crm`. One row per query. (Mode: Search.)

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

Chrome Web Store URLs (e.g. `https://chromewebstore.google.com/detail/grammarly.../kbfnbcaeplbcioakkpcpgfkobkghlhen`) or bare 32-character extension IDs. (Mode: Extension details.)

## `startUrls` (type: `array`):

Paste any mix of Chrome Web Store detail URLs and `/search/<query>` URLs — each is auto-routed to the right job. An alternative to the two fields above.

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

Cap the number of extensions returned per search query. The Chrome Web Store returns a curated short result list per query (~10), so use several specific queries to broaden coverage. (Mode: Search.)

## `includeDeveloperContacts` (type: `boolean`):

Include the developer's public contact data — email, website, postal address, support URL and privacy policy — plus the lead score. This is the lead-gen payload. Turn off for metadata only.

## `includePermissions` (type: `boolean`):

Include the extension's requested permissions, host permissions, optional permissions, content-script count and manifest version (parsed from the embedded manifest) — the security / risk signal.

## `includeScreenshots` (type: `boolean`):

Include the extension's store screenshot image URLs.

## `enrichDeveloperContacts` (type: `boolean`):

Crawl the developer's own website (home + a contact/about page, max 3 pages) for extra emails, a phone number and social profiles (LinkedIn, X, Facebook, GitHub…). Only runs for extensions that expose a developer website. Adds requests.

## `deduplicateExtensions` (type: `boolean`):

Emit each extension at most once per run, even if several search queries return it.

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

Two-letter language code (e.g. `en`, `es`, `de`) for titles, descriptions and the search storefront.

## `monitorMode` (type: `boolean`):

Remember which extensions were already returned and emit ONLY extensions not seen in previous runs. Pairs with Apify Schedules to track newly published / newly ranking extensions over time. State is kept in the key-value store below.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' extension ids for monitoring mode. Use a different name per tracked query set to keep their histories separate.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. Lower it if you hit rate limits on very large runs.

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

Proxy settings. The Chrome Web Store has no hard anti-bot, so the default Apify proxy is plenty.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "screenshot"
  ],
  "extensionUrls": [
    "kbfnbcaeplbcioakkpcpgfkobkghlhen"
  ],
  "maxResultsPerQuery": 30,
  "includeDeveloperContacts": true,
  "includePermissions": true,
  "includeScreenshots": true,
  "enrichDeveloperContacts": false,
  "deduplicateExtensions": true,
  "language": "en",
  "monitorMode": false,
  "monitorStoreName": "chrome-web-store-monitor",
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped extension records in the default dataset.

# 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 = {
    "searchQueries": [
        "screenshot"
    ],
    "extensionUrls": [
        "kbfnbcaeplbcioakkpcpgfkobkghlhen"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchQueries": ["screenshot"],
    "extensionUrls": ["kbfnbcaeplbcioakkpcpgfkobkghlhen"],
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "screenshot"
  ],
  "extensionUrls": [
    "kbfnbcaeplbcioakkpcpgfkobkghlhen"
  ]
}' |
apify call scrapesage/chrome-web-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/chrome-web-store-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chrome Web Store Scraper — Extensions & Developer Leads",
        "description": "Scrape Chrome Web Store extensions: search by keyword or pull full details by URL/ID. Returns ratings, install counts, version, size, permissions, manifest, screenshots and developer contacts (email, website, address) as B2B leads. Monitoring mode for new extensions. No browser, no login.",
        "version": "0.1",
        "x-build-id": "BXc1si1rD9XzGbX7c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~chrome-web-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-chrome-web-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesage~chrome-web-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-chrome-web-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesage~chrome-web-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-chrome-web-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "search",
                            "extensionDetails"
                        ],
                        "type": "string",
                        "description": "`Search` discovers extensions by keyword and pulls the full record for each result. `Extension details` pulls the full record (incl. developer leads & permissions) for specific extensions by URL or ID.",
                        "default": "search"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search the Chrome Web Store for, e.g. `screenshot`, `ad blocker`, `crm`. One row per query. (Mode: Search.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extensionUrls": {
                        "title": "Extension URLs or IDs",
                        "type": "array",
                        "description": "Chrome Web Store URLs (e.g. `https://chromewebstore.google.com/detail/grammarly.../kbfnbcaeplbcioakkpcpgfkobkghlhen`) or bare 32-character extension IDs. (Mode: Extension details.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Paste any mix of Chrome Web Store detail URLs and `/search/<query>` URLs — each is auto-routed to the right job. An alternative to the two fields above.",
                        "items": {
                            "type": "object"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Cap the number of extensions returned per search query. The Chrome Web Store returns a curated short result list per query (~10), so use several specific queries to broaden coverage. (Mode: Search.)",
                        "default": 30
                    },
                    "includeDeveloperContacts": {
                        "title": "Include developer contact / lead fields",
                        "type": "boolean",
                        "description": "Include the developer's public contact data — email, website, postal address, support URL and privacy policy — plus the lead score. This is the lead-gen payload. Turn off for metadata only.",
                        "default": true
                    },
                    "includePermissions": {
                        "title": "Include permissions & manifest signal",
                        "type": "boolean",
                        "description": "Include the extension's requested permissions, host permissions, optional permissions, content-script count and manifest version (parsed from the embedded manifest) — the security / risk signal.",
                        "default": true
                    },
                    "includeScreenshots": {
                        "title": "Include screenshot URLs",
                        "type": "boolean",
                        "description": "Include the extension's store screenshot image URLs.",
                        "default": true
                    },
                    "enrichDeveloperContacts": {
                        "title": "Enrich developer contacts from their website",
                        "type": "boolean",
                        "description": "Crawl the developer's own website (home + a contact/about page, max 3 pages) for extra emails, a phone number and social profiles (LinkedIn, X, Facebook, GitHub…). Only runs for extensions that expose a developer website. Adds requests.",
                        "default": false
                    },
                    "deduplicateExtensions": {
                        "title": "Deduplicate extensions within a run",
                        "type": "boolean",
                        "description": "Emit each extension at most once per run, even if several search queries return it.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter language code (e.g. `en`, `es`, `de`) for titles, descriptions and the search storefront.",
                        "default": "en"
                    },
                    "monitorMode": {
                        "title": "Monitoring mode — only new extensions",
                        "type": "boolean",
                        "description": "Remember which extensions were already returned and emit ONLY extensions not seen in previous runs. Pairs with Apify Schedules to track newly published / newly ranking extensions over time. State is kept in the key-value store below.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store that holds the 'already seen' extension ids for monitoring mode. Use a different name per tracked query set to keep their histories separate.",
                        "default": "chrome-web-store-monitor"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum parallel requests. Lower it if you hit rate limits on very large runs.",
                        "default": 6
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The Chrome Web Store has no hard anti-bot, so the default Apify proxy is plenty.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
