# Chrome Web Store Extension Watch (`mikee368/chrome-web-store-extension-watch`) Actor

Watch Chrome Web Store extensions you name by ID. Plain HTTP detail pages only. A row is stored when version, users, rating, last updated, or permissions change. The first run is a free baseline.

- **URL**: https://apify.com/mikee368/chrome-web-store-extension-watch.md
- **Developed by:** [Mike Berckmoes](https://apify.com/mikee368) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 extension changes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Chrome Web Store Extension Watch

**Watch extensions you already know by ID.** Give a list of Chrome Web Store extension IDs. Each run reads the detail page over plain HTTP (no browser), stores a hash of version, user count, rating, last updated and permissions, and returns a free baseline snapshot the first time an extension is seen. A later run returns a dataset row when that hash changes.

The first run is a free baseline: the hash is saved and one uncharged snapshot is stored (`type` `baseline`, with name, version, users, rating, and `updatedAt`). Later runs that see the same hash push nothing and are free. A change is the `extension-change` event.

### What you get

A baseline snapshot on the first check, then a row only when something watched changed:

| Field | Meaning |
|---|---|
| `extensionId`, `name`, `url` | The extension and the detail page that was read |
| `version`, `previousVersion` | Version now and on the previous run |
| `users`, `previousUsers` | User count now and before |
| `rating`, `previousRating` | Rating now and before |
| `lastUpdated`, `previousLastUpdated` | Store last-updated time (UTC) |
| `permissions`, `previousPermissions` | Manifest permissions and host permissions |
| `changedFields` | Which of those five fields changed |
| `hash`, `previousHash` | SHA-256 of the five watched fields |

### How to use it

1. Paste up to **500** extension IDs (32 letters from `a` to `p`), for example `aapbdbdomjkkjkaonfhkkikfgjllcleb`. The run status message shows that cap. IDs past 500 are not fetched.
2. Run once to store the baseline. The dataset gets one uncharged snapshot per extension. That run is not charged.
3. Schedule the same Monitor ID (daily is enough for a v1). The next run returns a row only for extensions whose version, users, rating, last updated or permissions changed.

There is no sitemap crawl, no search, and no review pages.

### How much does it cost?

Pay per change: **`extension-change` at $0.003** per extension whose watched fields changed. Unchanged checks are free and push nothing. The first baseline is free (hash stored, snapshot row, no charge).

Runs use 128–256 MB.

### Good to know

- **robots.txt.** The Actor reads `https://chromewebstore.google.com/robots.txt` first and skips any detail URL it disallows. If robots.txt cannot be read (network error or HTTP 5xx), no detail page is fetched and the run still succeeds with that note. Review, privacy, support and search paths are disallowed by the store and are not requested anyway.
- **Detail pages only.** The URL is `/detail/<id>`. The Actor parses the embedded `AF_initDataCallback` data. It does not open a browser.
- **What is hashed.** Version, users, rating, last updated, and permissions (including host permissions). The name is stored for the row but is not part of the hash.
- **Not found.** An unknown ID is reported in the run summary and is not charged.

### Input example

```json
{
  "extensionIds": ["aapbdbdomjkkjkaonfhkkikfgjllcleb"],
  "monitorId": "default"
}
```

# Actor input Schema

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

Chrome Web Store extension IDs (32 letters a-p), one per line, at most 500 per run. The form starts with Google Translate and Google Docs Offline; replace them with the extensions you watch. The status message shows this cap. The Actor fetches only /detail/<id>. It does not crawl the sitemap, search, or reviews.

## `monitorId` (type: `string`):

Name of the watch state (one hash per extension). Use different IDs for different lists.

## `resetState` (type: `boolean`):

Forget stored hashes for this Monitor ID. The next run is a free baseline again.

## Actor input object example

```json
{
  "extensionIds": [
    "aapbdbdomjkkjkaonfhkkikfgjllcleb",
    "ghbmnnjooekpmoecnnnilnnbdlolhkhi"
  ],
  "monitorId": "default",
  "resetState": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with one row per changed extension

## `summary` (type: `string`):

Baselines, unchanged checks, changes and problems

# 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 = {
    "extensionIds": [
        "aapbdbdomjkkjkaonfhkkikfgjllcleb",
        "ghbmnnjooekpmoecnnnilnnbdlolhkhi"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mikee368/chrome-web-store-extension-watch").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 = { "extensionIds": [
        "aapbdbdomjkkjkaonfhkkikfgjllcleb",
        "ghbmnnjooekpmoecnnnilnnbdlolhkhi",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mikee368/chrome-web-store-extension-watch").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 '{
  "extensionIds": [
    "aapbdbdomjkkjkaonfhkkikfgjllcleb",
    "ghbmnnjooekpmoecnnnilnnbdlolhkhi"
  ]
}' |
apify call mikee368/chrome-web-store-extension-watch --silent --output-dataset

```

## MCP server setup

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

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/OH60JncbQ2eW5kGzt/builds/ObdCwhva9Mhv3fPyS/openapi.json