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

Export Firefox Add-ons reviews and star ratings by extension URL or slug for sentiment, competitor, and release monitoring.

- **URL**: https://apify.com/automation-lab/firefox-addons-reviews-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 Reviews Scraper

Export public reviews and star ratings from Mozilla Firefox Add-ons by add-on URL, slug, or numeric ID.

Use this actor to monitor extension reputation, compare competitor feedback, and build repeatable review exports from the official Mozilla Add-ons public API.

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

Firefox Add-ons Reviews Scraper collects individual rating and review records from addons.mozilla.org.

It accepts Firefox add-on URLs such as `https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/` or slugs such as `ublock-origin`.

For every saved review or rating, the actor outputs add-on metadata, rating score, review text when present, reviewer profile fields, version information, source URLs, and scrape timestamps.

The actor uses Mozilla's public JSON API, so it does not require a Firefox account, browser automation, or credentials.

### Who is it for?

- 🧩 Browser extension product teams tracking release feedback.
- 📈 SEO and app-market researchers comparing extension reputation.
- 🛡️ Trust and safety teams watching negative review spikes.
- 🧪 QA teams checking whether new versions trigger user complaints.
- 🧑‍💼 Agencies reporting Firefox add-on sentiment to clients.
- 🧭 Competitive intelligence teams monitoring rival extensions.

### Why use this actor?

Manual review checking is slow and inconsistent.

Firefox Add-ons Reviews Scraper turns review pages into structured datasets that can be filtered, joined, scheduled, and exported.

You can run it daily for a small list of add-ons, export thousands of reviews for deeper research, or feed the output into dashboards and alerting workflows.

### Data you can extract

| Field | Description |
| --- | --- |
| `addonSlug` | Firefox Add-ons slug |
| `addonName` | Localized add-on name |
| `reviewId` | Mozilla review/rating identifier |
| `score` | 1-5 star rating |
| `body` | Written review text, when available |
| `createdAt` | Review creation timestamp |
| `userName` | Reviewer display name |
| `userUrl` | Reviewer profile URL |
| `version` | Add-on version tied to the review |
| `reviewUrl` | Public review URL |
| `sourceUrl` | API page used for the record |
| `scrapedAt` | Actor scrape timestamp |

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

The actor uses pay-per-event pricing.

There is a small run start event and a per-review event for each dataset item saved.

The default public pricing is designed for monitoring workloads and bulk exports.

You can control cost with `maxReviewsPerAddon` and by limiting the number of add-ons per run.

### Input options

#### `addonUrlsOrSlugs`

Required list of Firefox add-ons to export.

Accepted values include:

- `ublock-origin`
- `privacy-badger17`
- `https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/`
- Numeric add-on IDs when supported by the Mozilla API

#### `maxReviewsPerAddon`

Maximum review/rating records to save for each add-on.

Use `100` for a practical monitoring export.

Use higher values for one-time historical analysis.

#### `score`

Optional exact star filter.

For example, use `1` to collect only one-star reviews for complaint monitoring.

#### `sort`

Optional Mozilla API sort parameter.

Leave empty for the API default, which is normally newest first.

#### `locale`

Locale used for localized add-on names and output review URLs.

Default: `en-US`.

#### `includeRatingsWithoutText`

Firefox users may leave star ratings without written review text.

Keep this enabled for complete rating exports.

Disable it when you only need written feedback.

### Example input

```json
{
  "addonUrlsOrSlugs": [
    "ublock-origin",
    "https://addons.mozilla.org/en-US/firefox/addon/privacy-badger17/"
  ],
  "maxReviewsPerAddon": 100,
  "locale": "en-US",
  "includeRatingsWithoutText": true
}
````

### Example output

```json
{
  "addonSlug": "ublock-origin",
  "addonName": "uBlock Origin",
  "reviewId": 2725854,
  "score": 5,
  "body": "Overall a wonderful blocking extension...",
  "createdAt": "2026-07-05T00:00:07Z",
  "userName": "Firefox user",
  "version": "1.72.0",
  "reviewUrl": "https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/reviews/2725854/",
  "scrapedAt": "2026-07-05T00:00:00.000Z"
}
```

### How to scrape Firefox add-on reviews

1. Open the actor on Apify.
2. Paste one or more Firefox add-on URLs or slugs.
3. Set the maximum number of reviews per add-on.
4. Optionally filter by star rating.
5. Run the actor.
6. Download results from the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Monitoring workflows

Schedule the actor to run daily for your own Firefox add-ons.

Send results to a database or spreadsheet.

Filter for one-star and two-star ratings.

Alert your team when new negative reviews mention crashes, privacy, ads, login, payments, or broken features.

### Competitive research workflows

Add competitor extension slugs to the input list.

Export the newest 100-500 reviews for each extension.

Compare recurring complaints, requested features, and version-related issues.

Use the `version` field to detect whether recent releases changed sentiment.

### SEO and app-market research workflows

Firefox Add-ons reviews contain natural user language.

Researchers can mine review text for keywords, feature phrases, competitor names, and pain points.

The dataset is structured enough to join with listing metadata from related add-on scrapers.

### Tips for reliable exports

- Keep small scheduled runs for monitoring.
- Increase `maxReviewsPerAddon` for historical backfills.
- Use `score` to focus on positive testimonials or negative complaints.
- Keep `includeRatingsWithoutText` enabled when calculating rating distributions.
- Disable rating-only records when doing text mining.

### Integrations

Use Apify integrations to send Firefox Add-ons reviews to:

- Google Sheets for lightweight reputation tracking.
- BigQuery or Snowflake for analytics.
- Slack or email alerts for new negative feedback.
- Make or Zapier workflows for no-code reporting.
- Webhooks for custom dashboards and internal tools.

### 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-reviews-scraper').call({
  addonUrlsOrSlugs: ['ublock-origin'],
  maxReviewsPerAddon: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/firefox-addons-reviews-scraper').call(run_input={
    'addonUrlsOrSlugs': ['ublock-origin'],
    'maxReviewsPerAddon': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~firefox-addons-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"addonUrlsOrSlugs":["ublock-origin"],"maxReviewsPerAddon":100}'
```

### MCP usage

Use Apify MCP with Claude Desktop or Claude Code to run the actor from natural language prompts.

MCP endpoint:

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

Claude Code setup:

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

Claude Desktop JSON setup:

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

Example prompts:

- "Export the newest 100 Firefox reviews for uBlock Origin."
- "Get only one-star Firefox Add-ons reviews for Privacy Badger."
- "Compare recent review text for these Firefox extension slugs."

### Related scrapers

- [Chrome Web Store Reviews Scraper](https://apify.com/automation-lab/chrome-web-store-reviews-scraper)
- [Chrome Web Store Listing Scraper](https://apify.com/automation-lab/chrome-web-store-listing-scraper)
- [Firefox Add-ons Scraper](https://apify.com/automation-lab/firefox-addons-scraper)

### Limitations

This actor exports publicly available Mozilla Add-ons ratings and reviews.

It does not access private user data.

It depends on fields returned by the Mozilla Add-ons API.

If Mozilla changes API names or pagination behavior, the actor may need an update.

### Legality

The actor collects publicly available review data from Mozilla Add-ons.

You are responsible for using the data in accordance with applicable laws, platform terms, and privacy obligations.

Avoid republishing personal data in ways that could violate privacy rights.

For compliance-sensitive workflows, consult your legal advisor.

### FAQ

#### Can I scrape reviews without a Firefox account?

Yes. The actor uses the public Mozilla Add-ons API and does not require login credentials.

#### Can I export only written reviews?

Yes. Set `includeRatingsWithoutText` to `false`.

#### Can I export only negative reviews?

Yes. Set `score` to `1` or `2` and choose a suitable review limit.

#### Why are some review bodies empty?

Firefox Add-ons allows users to leave star ratings without written text.

Disable `includeRatingsWithoutText` if those records are not useful for your workflow.

#### What if an add-on slug is invalid?

The actor reports the Mozilla API error for that slug. Check the input URL or slug and run again.

#### Can I schedule monitoring?

Yes. Use Apify schedules to run daily, weekly, or monthly.

### Support

If you need a field that is available in the Mozilla API but missing from the dataset, open an issue on the actor page.

Include the add-on slug, expected field, and example run when possible.

### Changelog

#### 0.1

Initial version for Firefox Add-ons public ratings and reviews.

# Actor input Schema

## `addonUrlsOrSlugs` (type: `array`):

Firefox Add-ons URLs, slugs, or numeric add-on IDs. Examples: ublock-origin, https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/

## `maxReviewsPerAddon` (type: `integer`):

Maximum rating/review records to save for each add-on. Use a small value for quick checks and a larger value for monitoring exports.

## `score` (type: `integer`):

Only export reviews with this exact star score. Leave empty to export all ratings.

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

Optional Mozilla API sort value. Leave empty for the API default (newest first).

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

Locale used for localized add-on names and review URLs.

## `includeRatingsWithoutText` (type: `boolean`):

Firefox users can leave star ratings without text. Disable this to export only written reviews.

## Actor input object example

```json
{
  "addonUrlsOrSlugs": [
    "ublock-origin",
    "privacy-badger17"
  ],
  "maxReviewsPerAddon": 20,
  "locale": "en-US",
  "includeRatingsWithoutText": 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 = {
    "addonUrlsOrSlugs": [
        "ublock-origin",
        "privacy-badger17"
    ],
    "maxReviewsPerAddon": 20,
    "sort": "",
    "locale": "en-US",
    "includeRatingsWithoutText": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/firefox-addons-reviews-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 = {
    "addonUrlsOrSlugs": [
        "ublock-origin",
        "privacy-badger17",
    ],
    "maxReviewsPerAddon": 20,
    "sort": "",
    "locale": "en-US",
    "includeRatingsWithoutText": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/firefox-addons-reviews-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 '{
  "addonUrlsOrSlugs": [
    "ublock-origin",
    "privacy-badger17"
  ],
  "maxReviewsPerAddon": 20,
  "sort": "",
  "locale": "en-US",
  "includeRatingsWithoutText": true
}' |
apify call automation-lab/firefox-addons-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Firefox Add-ons Reviews Scraper",
        "description": "Export Firefox Add-ons reviews and star ratings by extension URL or slug for sentiment, competitor, and release monitoring.",
        "version": "0.1",
        "x-build-id": "fKBDnB3ajZfyfSLmb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~firefox-addons-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-firefox-addons-reviews-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-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-firefox-addons-reviews-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-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-firefox-addons-reviews-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": [
                    "addonUrlsOrSlugs"
                ],
                "properties": {
                    "addonUrlsOrSlugs": {
                        "title": "Firefox add-on URLs or slugs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Firefox Add-ons URLs, slugs, or numeric add-on IDs. Examples: ublock-origin, https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerAddon": {
                        "title": "Maximum reviews per add-on",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum rating/review records to save for each add-on. Use a small value for quick checks and a larger value for monitoring exports.",
                        "default": 20
                    },
                    "score": {
                        "title": "Star rating filter",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only export reviews with this exact star score. Leave empty to export all ratings."
                    },
                    "sort": {
                        "title": "Sort order",
                        "type": "string",
                        "description": "Optional Mozilla API sort value. Leave empty for the API default (newest first)."
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Locale used for localized add-on names and review URLs.",
                        "default": "en-US"
                    },
                    "includeRatingsWithoutText": {
                        "title": "Include ratings without review text",
                        "type": "boolean",
                        "description": "Firefox users can leave star ratings without text. Disable this to export only written reviews.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
