# Firefox Addons Scraper - Extension Metadata & Reviews (`klondikeking/firefox-addons-scraper`) Actor

Extract Firefox extension metadata, ratings, user counts, and category data using the official Mozilla Addons API. Fast, reliable, and no authentication required.

- **URL**: https://apify.com/klondikeking/firefox-addons-scraper.md
- **Developed by:** [Pierrick McD0nald](https://apify.com/klondikeking) (community)
- **Categories:** Developer tools, E-commerce
- **Stats:** 1 total users, 0 monthly users, 25.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Firefox Addons Scraper — Extension Metadata & User Analytics Extractor

Extract comprehensive metadata, ratings, user statistics, and category data for Firefox extensions using the official Mozilla Addons API. This Actor retrieves addon names, descriptions, ratings, daily active user counts, version information, and category tags. Perfect for browser extension research, competitive analysis, and marketplace monitoring.

### Use Cases

- **Extension Research** — Discover popular Firefox addons, compare ratings and user counts, and analyze feature descriptions across categories like privacy, productivity, and shopping.
- **Competitive Analysis** — Track competitor extensions, monitor their update frequency, user growth, and review sentiment to inform product decisions.
- **Marketplace Monitoring** — Stay informed about new releases, trending categories, and top-rated extensions in specific niches like ad blockers, password managers, or VPN tools.
- **Security Auditing** — Identify extensions with high user counts but low ratings, flag payment-required addons, and review update cadence for trust assessment.
- **Product Development** — Research successful extension patterns, analyze tag usage, and study category distributions to guide your own Firefox extension strategy.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Optional keyword to search addons by name or description (e.g., "password", "adblock", "vpn") |
| `maxItems` | Integer | No | Maximum addons to extract (default: 100, max: 1000) |
| `sortBy` | String | No | Sort results by: users, rating, created, updated, name, or downloads (default: users) |
| `category` | String | No | Filter by Firefox addon category (e.g., "privacy-security", "shopping", "productivity") |
| `proxyConfiguration` | Object | No | Proxy configuration for requests |

### Output

The Actor outputs a dataset with the following fields for each addon:

```json
{
  "name": "Bitwarden Password Manager",
  "slug": "bitwarden-password-manager",
  "authors": ["Bitwarden Inc."],
  "averageDailyUsers": 966907,
  "rating": 4.5991,
  "reviewCount": 3086,
  "categories": ["privacy-security"],
  "description": "At home, at work, or on the go, Bitwarden easily secures all your passwords...",
  "summary": "A secure and free password manager for all of your devices.",
  "version": "2026.5.1",
  "type": "extension",
  "tags": ["password-manager", "security"],
  "weeklyDownloads": 20929,
  "iconUrl": "https://addons.mozilla.org/user-media/addon_icons/735/735894-64.png",
  "url": "https://addons.mozilla.org/en-US/firefox/addon/bitwarden-password-manager/",
  "homepage": "https://bitwarden.com",
  "created": "2016-09-23T10:26:24Z",
  "lastUpdated": "2026-06-12T15:14:11Z",
  "status": "public",
  "requiresPayment": false
}
````

### Pricing

Pay per event: $0.001 per addon extracted.

### Limitations

- The Mozilla Addons API returns a maximum of 50 results per page. Large `maxItems` values require multiple API calls.
- The API is public and does not require authentication, but rate limits apply. The Actor includes retries and graceful backoff.
- Some fields may be null if the addon author has not provided them (e.g., description, homepage).
- Category filtering uses Mozilla's internal category names. Use the search query for broader discovery.

### FAQ

**Q: Can I extract all Firefox addons at once?**
A: The Mozilla API supports pagination up to a large number of results. Set `maxItems` to 1000 to get the most popular addons. For comprehensive extraction, run multiple searches with different keywords.

**Q: Do I need a proxy?**
A: No, the Mozilla Addons API is public and does not require authentication or proxy. However, you can configure a proxy if your network requires it.

**Q: What categories are available?**
A: Common categories include: privacy-security, shopping, productivity, themes, search-tools, appearance, feeds-news-blogging, bookmarks, download-management, photos-music-videos, social-communication, tabs, web-development, and others.

### Changelog

- **v1.0.0** — Initial release with full extension metadata, ratings, user statistics, and category filtering

# Actor input Schema

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

Optional keyword to search addons by name or description (e.g., password, adblock, vpn)

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

Maximum number of addons to extract (1-1000)

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

Sort order for results

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

Filter by Firefox addon category (e.g., privacy-security, shopping, productivity, themes, search-tools)

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

Configure proxy settings for the scraper

## Actor input object example

```json
{
  "searchQuery": "password",
  "maxItems": 10,
  "sortBy": "users",
  "category": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Link to the extracted Firefox addon dataset

## `stats` (type: `string`):

Statistics about the run including items extracted and errors

# 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 = {
    "searchQuery": "password",
    "maxItems": 10,
    "sortBy": "users",
    "category": "",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("klondikeking/firefox-addons-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 = {
    "searchQuery": "password",
    "maxItems": 10,
    "sortBy": "users",
    "category": "",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("klondikeking/firefox-addons-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 '{
  "searchQuery": "password",
  "maxItems": 10,
  "sortBy": "users",
  "category": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call klondikeking/firefox-addons-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Firefox Addons Scraper - Extension Metadata & Reviews",
        "description": "Extract Firefox extension metadata, ratings, user counts, and category data using the official Mozilla Addons API. Fast, reliable, and no authentication required.",
        "version": "1.0",
        "x-build-id": "iiW23YeRblWUmqhHz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/klondikeking~firefox-addons-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-klondikeking-firefox-addons-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/klondikeking~firefox-addons-scraper/runs": {
            "post": {
                "operationId": "runs-sync-klondikeking-firefox-addons-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/klondikeking~firefox-addons-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-klondikeking-firefox-addons-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Optional keyword to search addons by name or description (e.g., password, adblock, vpn)",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of addons to extract (1-1000)",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "users",
                            "rating",
                            "created",
                            "updated",
                            "name",
                            "downloads"
                        ],
                        "type": "string",
                        "description": "Sort order for results",
                        "default": "users"
                    },
                    "category": {
                        "title": "Category Filter",
                        "type": "string",
                        "description": "Filter by Firefox addon category (e.g., privacy-security, shopping, productivity, themes, search-tools)",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings for the scraper"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
