# Chrome Extension Version History Scraper (`googleapi/chrome-extension-version-history-scraper`) Actor

Collect public Chrome extension version and update history.

- **URL**: https://apify.com/googleapi/chrome-extension-version-history-scraper.md
- **Developed by:** [Google API](https://apify.com/googleapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

This Actor extracts the public version and release-history evidence exposed on each Chrome Web Store extension listing. It distinguishes the current listing version from older public entries, keeps the raw release text, records honest date precision, and reports whether multiple releases were actually observed.

The record is expanded with canonical identity, full description and Overview text plus sanitized HTML, category, publisher contacts and address, trader status, ratings/reviews/users, current/latest version fields, release-history entries, website/support/privacy links, size, languages, features, screenshots, related IDs, and media metadata. The public Chrome Web Store detail page normally exposes only the current version and update date; older releases are emitted only when explicit version entries are present in the fetched source. Otherwise the output says `current_version_only` rather than fabricating older releases.

The Actor also saves its own observations between runs. Later runs compare the same extension with its earlier version and update date using `previousVersion`, `previousUpdatedAt`, `versionChanged`, and `versionComparison`. The first run establishes the starting point; future runs can report whether the observed version is unchanged or has changed. This comparison begins with the first run and does not recreate releases from before that observation. Saved history is limited to the 100 most recent observed versions per extension; avoid overlapping runs for the same extension.

### Inputs

Use `extensionIds` or official Chrome Web Store detail URLs for known extensions, or use `startUrls`, `sourceUrls`, or `urls` with search/category pages. `queries`, `query`, `searchQuery`, and `category` support public discovery. `maxItems`, `maxRequests`, and `maxDetailRequests` limit the amount collected. Only the first public listing batch is supported, so `page` and `maxPages` are fixed at `1`.

Only public Chrome Web Store pages are in scope. The Actor does not sign in, solve CAPTCHA challenges, use private publisher data, or infer release history not exposed by the source. A listing’s full description is retained as plain text and safe HTML.

### Output

Each dataset row represents one extension and includes its current version, observed release entries, and cross-run comparison fields. Each `versionHistory` entry can include the release date and its precision, an estimated-date indicator, a source-provided change summary, and whether it is the current version. Older releases are reported only when they appear in the source or were observed in earlier runs; otherwise `historyStatus` is `current_version_only`.

The run summary is available with the dataset in the Output tab. You can download dataset records in formats such as JSON, HTML, CSV, or Excel.

# Actor input Schema

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

One 32-character public Chrome extension ID.

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

Public Chrome extension IDs to inspect.

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

Public Chrome Web Store detail, search, or category URLs.

## `sourceUrls` (type: `array`):

Alias for startUrls.

## `urls` (type: `array`):

Alias for startUrls.

## `queries` (type: `array`):

Public Chrome Web Store search terms.

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

One search term.

## `searchQuery` (type: `string`):

Alias for query.

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

Optional Chrome Web Store category slug.

## `locale` (type: `string`):

Accepted for compatibility with locale-aware callers.

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

Alias for locale.

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

Maximum number of extension history records.

## `maxPages` (type: `integer`):

Only the initial public listing batch is currently supported.

## `maxRequests` (type: `integer`):

Maximum direct public page requests.

## `maxDetailRequests` (type: `integer`):

Maximum extension detail pages to inspect.

## `requestTimeoutSecs` (type: `integer`):

Maximum wait for each public request.

## `timeoutSecs` (type: `integer`):

Alias for requestTimeoutSecs.

## `requestTimeoutMs` (type: `integer`):

Millisecond form of the request timeout.

## `requestDelayMs` (type: `integer`):

Delay between public requests.

## `maxRetries` (type: `integer`):

Maximum retry attempts for failed requests.

## `userAgent` (type: `string`):

Optional ordinary browser user agent.

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

Compatibility-only: this Actor uses direct HTTP and does not apply proxy settings.

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

Only page 1 of public listings is currently supported.

## Actor input object example

```json
{
  "maxItems": 25,
  "maxPages": 1,
  "maxRequests": 50,
  "maxDetailRequests": 25,
  "requestTimeoutSecs": 25,
  "requestDelayMs": 0,
  "maxRetries": 1,
  "page": 1
}
```

# Actor output Schema

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

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("googleapi/chrome-extension-version-history-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("googleapi/chrome-extension-version-history-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call googleapi/chrome-extension-version-history-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,googleapi/chrome-extension-version-history-scraper"
        }
    }
}
```

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/iYd53xH6JZg8A1pE3/builds/nRHWySSgiYhlueFbe/openapi.json