# Shopify App Reviews Scraper (`fetch_cat/shopify-app-reviews-scraper`) Actor

Scrape public Shopify App Store reviews with star ratings, merchant details, app rating totals, filters, and developer replies.

- **URL**: https://apify.com/fetch\_cat/shopify-app-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 review records

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

## Shopify App Reviews Scraper

Scrape public Shopify App Store reviews, star ratings, merchant feedback, developer replies, and app-level rating metrics from Shopify app listings.

Use it to monitor competitor sentiment, discover merchant pain points, track support quality, and build review datasets for ecommerce app research.

### What does Shopify App Reviews Scraper do?

Shopify App Reviews Scraper collects public review records from Shopify App Store app pages.

It accepts app listing URLs or app handles and returns structured review rows in an Apify dataset.

Each row includes the app context, review rating, review text, date, merchant details when visible, and app-level rating totals.

### Who is it for?

#### Shopify app developers

Use review data to understand what merchants praise, what frustrates them, and where competing apps leave gaps.

#### Ecommerce agencies

Compare Shopify apps before recommending tools to clients.

#### Product managers

Track sentiment changes and prioritize roadmap ideas from real merchant feedback.

#### Investors and analysts

Measure market traction and customer happiness across Shopify ecosystem apps.

#### Support and success teams

Find recurring support complaints and developer response patterns.

### Why use this scraper?

- ⭐ Collect review text and star ratings in one dataset
- 🧭 Track competitor app sentiment over time
- 💬 Capture developer replies when visible
- 🏷️ Filter by star rating for targeted research
- 📊 Export clean data to CSV, JSON, Excel, or your BI tool
- 🔁 Schedule recurring runs on Apify

### What data can you extract?

| Field | Description |
| --- | --- |
| `appHandle` | Shopify App Store app handle |
| `appName` | App name shown on the listing |
| `appUrl` | Shopify App Store app URL |
| `reviewsUrl` | Review page URL used for the record |
| `aggregateRating` | App-level rating |
| `aggregateReviewCount` | App-level review count |
| `ratingDistribution` | Visible count by star rating |
| `reviewId` | Unique review identifier |
| `reviewUrl` | Direct review share URL |
| `rating` | Review star rating |
| `reviewText` | Merchant review text |
| `reviewDate` | Public review date text |
| `merchantName` | Merchant/store name when visible |
| `merchantCountry` | Merchant country when visible |
| `merchantUsage` | How long the merchant used the app, when visible |
| `developerReplyText` | Developer reply text when visible |
| `developerReplyDate` | Developer reply date when available |
| `pageNumber` | Review page number |
| `scrapedAt` | Timestamp when the record was scraped |

### How much does it cost to scrape Shopify App Store reviews?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-review fee for records saved to the dataset.

Small tests with a few reviews are inexpensive, while larger monitoring jobs scale with the number of review records collected.

### Quick start

1. Open the actor on Apify.
2. Paste one or more Shopify App Store app URLs.
3. Set the maximum number of reviews per app.
4. Optionally select star ratings to filter.
5. Click **Start**.
6. Download the results from the dataset.

### Input options

#### Shopify App Store app URLs

Paste URLs such as:

```text
https://apps.shopify.com/judgeme/reviews
https://apps.shopify.com/klaviyo-email-marketing
````

#### App handles

You can also enter handles directly:

```text
judgeme
klaviyo-email-marketing
```

#### Maximum reviews per app

Controls how many review rows are saved for each app.

Start with 25 for quick tests.

Increase the value for historical analysis.

#### Rating filter

Select one or more star ratings when you want only positive or negative reviews.

Examples:

- 5-star reviews for testimonial mining
- 1-star and 2-star reviews for pain-point research
- 3-star reviews for feature-gap discovery

#### Locale

Use a Shopify App Store locale code such as `en`, `de`, `fr`, `es`, `ja`, or `pt-BR`.

#### Maximum pages per app

A safety cap that prevents unexpectedly long runs.

Each Shopify App Store review page usually contains around ten reviews.

### Output example

```json
{
  "appHandle": "judgeme",
  "appName": "Judge.me Product Reviews App",
  "appUrl": "https://apps.shopify.com/judgeme",
  "reviewId": "2238961",
  "rating": 5,
  "reviewText": "Juge.me supports everything we could ask of a review platform...",
  "reviewDate": "June 10, 2026",
  "merchantName": "Makeup A Murder, INC",
  "merchantCountry": "United States",
  "merchantUsage": "Over 6 years using the app",
  "aggregateRating": 5,
  "aggregateReviewCount": 40553,
  "scrapedAt": "2026-06-27T19:14:07.583Z"
}
```

### Tips for better results

- Start with one app and a low review limit.
- Use rating filters for focused sentiment research.
- Schedule repeated runs if you want review monitoring.
- Use app handles when you already have a list of competitors.
- Keep page limits aligned with your maximum review count.

### Common use cases

#### Competitor review monitoring

Track competing Shopify apps and identify new complaints or praised features.

#### Voice-of-customer research

Export review text to analyze merchant language and buying triggers.

#### Product roadmap research

Find repeated feature requests and workflow blockers.

#### Agency app selection

Compare apps by merchant sentiment before recommending them to clients.

#### Reputation tracking

Monitor your own app reviews and developer reply coverage.

### Integrations

Use Apify integrations to send results to:

- Google Sheets for review dashboards
- Slack for new negative-review alerts
- Make or Zapier for automated workflows
- BigQuery or Snowflake for analytics
- Webhooks for custom monitoring systems

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/shopify-app-reviews-scraper').call({
  appUrls: [{ url: 'https://apps.shopify.com/judgeme/reviews' }],
  maxReviewsPerApp: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/shopify-app-reviews-scraper').call(run_input={
    'appUrls': [{'url': 'https://apps.shopify.com/judgeme/reviews'}],
    'maxReviewsPerApp': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~shopify-app-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"appUrls":[{"url":"https://apps.shopify.com/judgeme/reviews"}],"maxReviewsPerApp":25}'
```

### MCP usage

Connect this actor to MCP-compatible tools through Apify MCP Server.

Use this MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/shopify-app-reviews-scraper
```

Claude Code setup example:

```bash
claude mcp add apify-shopify-reviews https://mcp.apify.com/?tools=fetch_cat/shopify-app-reviews-scraper
```

MCP JSON configuration example:

```json
{
  "mcpServers": {
    "apify-shopify-reviews": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/shopify-app-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the latest 50 reviews for the Judge.me Shopify app."
- "Find 1-star reviews for this Shopify app and summarize merchant complaints."
- "Compare review sentiment for these three Shopify apps."

### Scheduling

Create an Apify schedule to run the scraper daily, weekly, or monthly.

This is useful for ongoing monitoring of your app or competitors.

### Export formats

Dataset results can be downloaded as:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML table

### Data quality notes

The actor returns fields that are publicly visible on Shopify App Store review pages.

Some merchant details or developer replies may be absent on specific reviews.

When a field is not visible, the value is returned as `null`.

### Limits

Shopify App Store review availability depends on the public listing.

Very old pages or filtered views may return fewer records than requested.

Use sensible review and page limits for predictable run time.

### FAQ

#### Can I use the scraper through the API?

Yes. Use the API examples above or call the actor from any Apify client with app URLs, handles, limits, and filters.

#### Can I use it with MCP?

Yes. Use the MCP URL and configuration examples above to connect the actor to compatible AI tools.

### Troubleshooting

#### The run returned no reviews

Check that the app handle or URL is valid and that the app has public reviews.

Try the app listing URL in a browser, then rerun with a small limit.

#### I got fewer reviews than requested

The selected rating filter may have fewer matching reviews, or the page limit may be too low.

Increase `maxPagesPerApp` or remove rating filters.

#### Some reply fields are empty

Developer replies are only returned when they are visible for a review.

### Legality

#### Is it legal to scrape Shopify App Store reviews?

This actor collects publicly available information from Shopify App Store pages.

You are responsible for using the data in line with applicable laws, Shopify terms, and privacy requirements.

Avoid collecting or using personal data in a way that violates regulations or platform rules.

### Related scrapers

- https://apify.com/fetch\_cat/shopify-app-store-scraper
- https://apify.com/fetch\_cat/shopify-products-scraper
- https://apify.com/fetch\_cat/google-play-reviews-scraper
- https://apify.com/fetch\_cat/apple-app-store-reviews-scraper

### Support

If you need a field that is visible on Shopify App Store review pages but missing from the output, open an issue on Apify and include a sample app URL.

### Changelog

#### 0.1

Initial version for public Shopify App Store review extraction.

# Actor input Schema

## `appUrls` (type: `array`):

Paste Shopify App Store listing or reviews URLs, such as https://apps.shopify.com/judgeme or https://apps.shopify.com/judgeme/reviews.

## `appHandles` (type: `array`):

Optional Shopify App Store handles. Use this when you already know the handle, for example judgeme.

## `maxReviewsPerApp` (type: `integer`):

Maximum number of review records to save for each app.

## `ratings` (type: `array`):

Optional star ratings to scrape. Leave empty to include all ratings.

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

Optional Shopify App Store locale code, for example en, de, fr, es, ja, pt-BR.

## `maxPagesPerApp` (type: `integer`):

Safety cap for review pagination. Each page usually contains around 10 reviews.

## Actor input object example

```json
{
  "appUrls": [
    {
      "url": "https://apps.shopify.com/judgeme/reviews"
    }
  ],
  "appHandles": [
    "judgeme"
  ],
  "maxReviewsPerApp": 20,
  "locale": "en",
  "maxPagesPerApp": 5
}
```

# 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 = {
    "appUrls": [
        {
            "url": "https://apps.shopify.com/judgeme/reviews"
        }
    ],
    "appHandles": [
        "judgeme"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/shopify-app-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 = {
    "appUrls": [{ "url": "https://apps.shopify.com/judgeme/reviews" }],
    "appHandles": ["judgeme"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/shopify-app-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 '{
  "appUrls": [
    {
      "url": "https://apps.shopify.com/judgeme/reviews"
    }
  ],
  "appHandles": [
    "judgeme"
  ]
}' |
apify call fetch_cat/shopify-app-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify App Reviews Scraper",
        "description": "Scrape public Shopify App Store reviews with star ratings, merchant details, app rating totals, filters, and developer replies.",
        "version": "0.1",
        "x-build-id": "uoEh1xEP13wieJVLO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~shopify-app-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-shopify-app-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/fetch_cat~shopify-app-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-shopify-app-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/fetch_cat~shopify-app-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-shopify-app-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",
                "properties": {
                    "appUrls": {
                        "title": "Shopify App Store app URLs",
                        "type": "array",
                        "description": "Paste Shopify App Store listing or reviews URLs, such as https://apps.shopify.com/judgeme or https://apps.shopify.com/judgeme/reviews.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "appHandles": {
                        "title": "App handles",
                        "type": "array",
                        "description": "Optional Shopify App Store handles. Use this when you already know the handle, for example judgeme.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum reviews per app",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of review records to save for each app.",
                        "default": 20
                    },
                    "ratings": {
                        "title": "Rating filter",
                        "type": "array",
                        "description": "Optional star ratings to scrape. Leave empty to include all ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        }
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Optional Shopify App Store locale code, for example en, de, fr, es, ja, pt-BR.",
                        "default": "en"
                    },
                    "maxPagesPerApp": {
                        "title": "Maximum pages per app",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety cap for review pagination. Each page usually contains around 10 reviews.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```