# Firefox Add-ons Scraper (`automation-lab/firefox-addons-scraper`) Actor

Extract Firefox Add-ons users, ratings, versions, authors, permissions, categories, support links, and compatibility from Mozilla’s public API.

- **URL**: https://apify.com/automation-lab/firefox-addons-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Firefox Add-ons Scraper

Extract structured Firefox Add-ons marketplace data from Mozilla's public add-ons API.

Use this actor to collect extension names, slugs, user counts, ratings, versions, authors, categories, permissions, compatibility ranges, support links, and update timestamps from addons.mozilla.org.

### What does Firefox Add-ons Scraper do?

Firefox Add-ons Scraper turns Firefox Add-ons search results and add-on pages into clean dataset rows.

It supports two workflows:

- 🔎 Search the Firefox Add-ons marketplace by keyword.
- 🔗 Fetch specific add-ons from start URLs.

The actor uses Mozilla's public JSON API, so it is lightweight, fast, and does not need a browser.

### Who is it for?

This scraper is useful for teams that monitor browser-extension markets.

- 🧑‍💼 Product marketers compare competing add-ons by users, ratings, and release cadence.
- 🧑‍🔬 Market researchers build category maps for VPN, SEO, privacy, AI, or developer-tool add-ons.
- 🧑‍💻 Developer-relations teams identify popular extension authors and support channels.
- 🕵️ Security and compliance teams review extension permissions at scale.
- 📈 SEO agencies track Firefox visibility for browser add-ons alongside Chrome Web Store research.

### Why use this Firefox add-ons extractor?

Firefox Add-ons pages are designed for browsing, not bulk analysis.

This actor returns normalized JSON that is ready for spreadsheets, BI tools, alerts, and enrichment pipelines.

You can repeatedly run the same query and compare:

- daily user counts
- rating averages
- rating counts
- latest version numbers
- last-updated timestamps
- permission changes
- support and homepage links

### Data you can extract

The dataset includes marketplace, ranking, technical, and traceability fields.

| Field | Description |
| --- | --- |
| `name` | Localized add-on name |
| `slug` | Mozilla Add-ons slug |
| `guid` | Add-on GUID |
| `url` | Public Firefox Add-ons URL |
| `summary` | Short marketplace summary |
| `description` | Longer add-on description when available |
| `averageDailyUsers` | Mozilla average daily user estimate |
| `weeklyDownloads` | Weekly download count when returned |
| `ratingsAverage` | Average rating |
| `ratingsCount` | Total rating count |
| `ratingsTextCount` | Written review count |
| `currentVersion` | Current version string |
| `lastUpdated` | Last update timestamp |
| `authors` | Structured author objects |
| `categories` | Firefox Add-ons categories |
| `permissions` | Requested extension permissions |
| `compatibility` | Firefox min/max compatibility |
| `iconUrl` | Add-on icon URL |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape Firefox Add-ons?

The actor uses pay-per-event pricing.

You pay a tiny start fee plus a per-add-on item fee.

The exact live price is shown on the Apify actor page before you run it.

Because this actor uses HTTP API calls instead of a browser, typical runs are inexpensive.

### Input options

You can provide search queries, start URLs, or both.

```json
{
  "queries": ["seo", "password manager"],
  "maxItems": 100,
  "sort": "users",
  "locale": "en-US",
  "includeDetails": true
}
````

### Search queries

Use `queries` when you want marketplace discovery.

Examples:

- `seo`
- `vpn`
- `password manager`
- `privacy`
- `developer tools`
- `screen recorder`

The actor paginates Mozilla Add-ons search results until it reaches `maxItems`.

### Start URLs

Use `startUrls` when you already know the add-ons or search pages you want.

Supported URL types:

- Firefox add-on pages, for example `https://addons.mozilla.org/en-US/firefox/addon/seoquake-seo-extension/`
- Mozilla Add-ons API detail URLs
- Mozilla Add-ons API search URLs

Unsupported URLs are skipped with a warning.

### Sorting and locale

The `sort` input controls Mozilla search ordering.

Common values include:

- `users`
- `rating`
- `updated`
- `created`
- `name`
- `relevance`

The `locale` input controls localized names, summaries, and descriptions where Mozilla provides them.

### Output example

```json
{
  "name": "SEOquake",
  "slug": "seoquake-seo-extension",
  "url": "https://addons.mozilla.org/en-US/firefox/addon/seoquake-seo-extension/",
  "averageDailyUsers": 13558,
  "ratingsAverage": 4.4,
  "ratingsCount": 900,
  "currentVersion": "3.9.9",
  "lastUpdated": "2023-01-03T12:07:49Z",
  "categories": ["web-development", "search-tools"],
  "permissions": ["contextMenus", "tabs", "storage"],
  "sourceQuery": "seo",
  "scrapedAt": "2026-06-23T00:00:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Enter one or more Firefox Add-ons search queries.
3. Set `maxItems` to the number of add-ons you need.
4. Choose the sort order.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for better results

- Start with `sort: users` to find established add-ons.
- Use `sort: updated` to monitor recently maintained add-ons.
- Use exact category keywords for cleaner market maps.
- Keep `includeDetails` enabled when you need permissions or compatibility fields.
- Run the same query weekly to detect version and rating changes.

### Integrations

Firefox Add-ons Scraper works well in automated workflows.

Examples:

- Send new high-user add-ons to Slack.
- Export permissions into a security review sheet.
- Join Firefox add-on data with Chrome Web Store data.
- Monitor competitor version changes in Airtable.
- Feed category-level metrics into a dashboard.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/firefox-addons-scraper').call({
  queries: ['seo'],
  maxItems: 100,
  sort: 'users',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage: Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/firefox-addons-scraper').call(run_input={
    'queries': ['password manager'],
    'maxItems': 50,
    'sort': 'users',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~firefox-addons-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["vpn"],"maxItems":50,"sort":"users"}'
```

### MCP integration

Use this actor through the Apify MCP server with Claude Desktop, Claude Code, or other MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/firefox-addons-scraper
```

Claude Code setup:

```bash
claude mcp add apify-firefox-addons https://mcp.apify.com/?tools=automation-lab/firefox-addons-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-firefox-addons": {
      "url": "https://mcp.apify.com/?tools=automation-lab/firefox-addons-scraper"
    }
  }
}
```

Example prompts:

- "Find the top Firefox VPN add-ons and summarize their permissions."
- "Compare Firefox SEO add-ons by users, ratings, and last update date."
- "Create a table of password manager add-ons with support URLs and authors."

### Monitoring workflows

Scheduled runs are especially useful for extension tracking.

You can store each run's dataset and compare rows over time.

Useful changes to monitor:

- version changed
- daily users increased or decreased
- rating count changed
- rating average dropped
- permissions changed
- support URL changed
- add-on disappeared from search results

### Performance and reliability

The actor is HTTP-only and uses Mozilla's public API.

It does not launch Chrome, Firefox, or Playwright.

It retries rate-limit responses with bounded backoff and keeps unsupported URLs from crashing the whole run.

### Limitations

The actor returns what Mozilla's public API exposes.

Some fields may be empty for add-ons that do not publish support links, homepage links, detailed descriptions, or certain permission categories.

Mozilla's rankings and average daily user counts are estimates from the marketplace source.

### Legality

This actor extracts public metadata from Mozilla Add-ons.

You are responsible for using the data in accordance with Mozilla's terms, applicable laws, and your internal compliance rules.

Avoid collecting or storing personal data unless you have a lawful basis.

### Related scrapers

Other automation-lab actors that pair well with Firefox Add-ons Scraper:

- Chrome Web Store scrapers for cross-browser extension intelligence.
- Website Contact Finder for enriching add-on homepages.
- Google Search scrapers for extension visibility research.
- URL status checkers for monitoring homepage and support links.

### FAQ

#### Can I scrape one specific Firefox add-on?

Yes. Put the add-on page in `startUrls` and set `maxItems` to `1`.

#### Can I scrape by category?

Use category-like search terms or Mozilla search URLs in `startUrls`.

#### Why are some permission arrays empty?

Mozilla may omit optional permission groups for add-ons that do not request them.

#### Why is a description not in my language?

If the requested locale is missing, the actor falls back to `en-US` or the first localized text returned by Mozilla.

#### Does the actor need proxies?

No. The MVP uses Mozilla's public unauthenticated JSON API and does not configure proxies.

### Changelog

- `0.1` Initial version with query search, add-on URL support, detail enrichment, ratings, users, versions, permissions, compatibility, and author fields.

# Actor input Schema

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

Search terms to run on addons.mozilla.org, such as SEO, password manager, VPN, ad blocker, or developer tools.

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

Optional Firefox Add-ons search URLs or individual add-on URLs. Search URLs are paginated; add-on URLs fetch that exact add-on.

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

Maximum number of add-ons to save across all queries and URLs. Keep the prefill low for a cheap first run.

## `sort` (type: `string`):

Mozilla Add-ons search sort. Common values include users, rating, updated, created, name, and relevance.

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

Preferred locale for localized names, summaries, and descriptions returned by Mozilla Add-ons.

## `includeDetails` (type: `boolean`):

When enabled, fetches the add-on detail API for each result to maximize permissions, compatibility, and author fields.

## Actor input object example

```json
{
  "queries": [
    "seo",
    "password manager"
  ],
  "startUrls": [
    {
      "url": "https://addons.mozilla.org/en-US/firefox/addon/seoquake-seo-extension/"
    }
  ],
  "maxItems": 20,
  "sort": "users",
  "locale": "en-US",
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "seo",
        "password manager"
    ],
    "startUrls": [
        {
            "url": "https://addons.mozilla.org/en-US/firefox/addon/seoquake-seo-extension/"
        }
    ],
    "maxItems": 20,
    "sort": "users",
    "locale": "en-US",
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "queries": [
        "seo",
        "password manager",
    ],
    "startUrls": [{ "url": "https://addons.mozilla.org/en-US/firefox/addon/seoquake-seo-extension/" }],
    "maxItems": 20,
    "sort": "users",
    "locale": "en-US",
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "queries": [
    "seo",
    "password manager"
  ],
  "startUrls": [
    {
      "url": "https://addons.mozilla.org/en-US/firefox/addon/seoquake-seo-extension/"
    }
  ],
  "maxItems": 20,
  "sort": "users",
  "locale": "en-US",
  "includeDetails": true
}' |
apify call automation-lab/firefox-addons-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Firefox Add-ons Scraper",
        "description": "Extract Firefox Add-ons users, ratings, versions, authors, permissions, categories, support links, and compatibility from Mozilla’s public API.",
        "version": "0.1",
        "x-build-id": "zRl6jYUujlbmgvaPv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~firefox-addons-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~firefox-addons-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~firefox-addons-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Search terms to run on addons.mozilla.org, such as SEO, password manager, VPN, ad blocker, or developer tools.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Firefox Add-ons search URLs or individual add-on URLs. Search URLs are paginated; add-on URLs fetch that exact add-on.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Firefox Add-ons search URL, add-on page URL, or Mozilla Add-ons API URL."
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum add-ons",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of add-ons to save across all queries and URLs. Keep the prefill low for a cheap first run.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "users",
                            "rating",
                            "updated",
                            "created",
                            "name",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Mozilla Add-ons search sort. Common values include users, rating, updated, created, name, and relevance.",
                        "default": "users"
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Preferred locale for localized names, summaries, and descriptions returned by Mozilla Add-ons.",
                        "default": "en-US"
                    },
                    "includeDetails": {
                        "title": "Fetch detail endpoint",
                        "type": "boolean",
                        "description": "When enabled, fetches the add-on detail API for each result to maximize permissions, compatibility, and author fields.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
