# Seed Product Reviews Scraper (`reviewly/seed-product-reviews-scraper`) Actor

Scrapes all customer reviews from seed.com with filtering by date, topic, and sort order.

- **URL**: https://apify.com/reviewly/seed-product-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** Developer tools, Integrations, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 record scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Seed.com Product Reviews Scraper

**Extract verified customer reviews and full product data from any Seed.com product page — structured, clean, and ready to analyze.**

- ✅ No API key or cookies required
- ✅ Cloudflare bypass built in
- ✅ Sentiment scores, verified buyer flag, and author data included
- ✅ Full product metadata alongside every review
- ✅ Multi-product support in a single run

---

### What This Actor Does

[Seed.com](https://seed.com) is a leading **health and wellness brand** specializing in **probiotics and synbiotics** — science-backed supplements that support gut health, immunity, skin health, and more. Their product line includes the DS-01® Daily Synbiotic, DM-02™ Daily Multivitamin, PM-02™ Sleep + Restore, and others, each backed by clinical research and carrying thousands of verified customer reviews.

This Apify Actor scrapes those customer reviews and product metadata from any Seed.com product page. Give it a product URL and it returns a structured dataset containing every available review alongside full product details — no authentication, cookies, or API credentials needed.

Built for **marketers, market researchers, probiotic and supplement brands, and health & wellness analysts** who need reliable access to real consumer sentiment data.

---

### Key Features

- Scrapes all verified customer reviews per product
- Extracts full product metadata (price, images, benefits, ingredients)
- Sentiment score included on every review
- Verified buyer flag per review
- Filter reviews by date range
- Sort by date, score, or relevance
- Multi-product support in one run
- Residential proxy support for scale
- Automatic pagination — stops when all reviews are collected

---

### Why This Actor Stands Out

- **No session hacks.** Most scrapers rely on browser cookies that expire within hours. This actor uses browser-level TLS fingerprinting to access Seed's review API directly — no credentials, no maintenance.
- **Rich data, not just text.** Each result includes the review score, sentiment score, verified buyer status, vote counts, author details, and topics — not just the review body.
- **Product metadata included.** Price, description, images, ingredient list, benefits, and Yotpo aggregate rating come back in the same dataset item as the reviews.
- **Scales cleanly.** Handles hundreds of reviews per product without hitting rate limits. Add residential proxies for large-volume production runs.

---

### Input Configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` *(required)* | array | — | One or more Seed.com product page URLs |
| `maxNumberOfReviews` | integer | `0` (all) | Cap reviews per product. `0` = scrape all. Free users capped at 50. |
| `sortBy` | string | `"date"` | Sort field: `"date"`, `"score"`, or `"relevant"` |
| `ascending` | boolean | `false` | `false` = newest/highest first. `true` = oldest/lowest first. |
| `targetDate` | string | `null` | Only include reviews on or after this date (`YYYY-MM-DD`) |
| `proxyConfiguration` | object | No proxy | Apify proxy settings. Residential recommended for large runs. |

#### Example Input

```json
{
  "startUrls": [
    { "url": "https://seed.com/daily-synbiotic" },
    { "url": "https://seed.com/daily-multivitamin" }
  ],
  "maxNumberOfReviews": 0,
  "sortBy": "date",
  "ascending": false,
  "targetDate": "2025-01-01",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

> **Tip:** Set `maxNumberOfReviews` to `0` to collect all reviews. The actor reads the total count directly from the product page and stops automatically when done.

***

### Output Format

The dataset contains **one item per product URL**. Each item has two top-level keys: `product` (metadata from the product page) and `reviews` (array of all matching reviews).

#### Product Object

| Field | Type | Description |
|---|---|---|
| `name` | string | Full product name (e.g. `DM-02™ Daily Multivitamin`) |
| `handle` | string | Shopify URL slug |
| `description` | string | Short product description |
| `price` | string | Starting price in USD |
| `tags` | array | Shopify product tags |
| `images` | array | Product image URLs |
| `benefits` | array | Marketing benefit bullet points |
| `ingredients` | array | Key ingredient groups |
| `yotpoAverageScore` | number | Aggregate review rating (e.g. `4.2`) |
| `yotpoTotalReviews` | integer | Total review count for this product |
| `shopifyId` | string | Shopify product GID |
| `sourceUrl` | string | The input URL that was scraped |

#### Review Object

| Field | Type | Description |
|---|---|---|
| `reviewId` | integer | Unique review identifier |
| `score` | integer | Star rating (1–5) |
| `title` | string | Review headline |
| `content` | string | Full review body text |
| `sentiment` | number | Sentiment score (0–1, higher = more positive) |
| `verifiedBuyer` | boolean | `true` if reviewer is a verified purchaser |
| `createdAt` | string | Submission date (ISO 8601) |
| `language` | string | Detected language (e.g. `"en"`) |
| `votesUp` | integer | Helpful votes |
| `votesDown` | integer | Not helpful votes |
| `author.displayName` | string | Reviewer display name |
| `author.userType` | string | Account type |
| `scrapedAt` | string | When the record was collected (ISO 8601) |

#### Sample Output

```json
{
  "product": {
    "name": "DM-02™ Daily Multivitamin",
    "price": "39.99",
    "yotpoAverageScore": 4.2,
    "yotpoTotalReviews": 267,
    "benefits": [
      "Meets 100% daily value of 20 vitamins and minerals",
      "Helps fill daily nutrient gaps with precise dosing"
    ],
    "sourceUrl": "https://seed.com/daily-multivitamin"
  },
  "reviews": [
    {
      "reviewId": 861847198,
      "score": 5,
      "title": "This sleep product is honestly in a category of its own",
      "content": "Amazing doesn't even come close...",
      "sentiment": 0.9345,
      "verifiedBuyer": true,
      "createdAt": "2026-06-26T12:40:01.000Z",
      "language": "en",
      "votesUp": 12,
      "author": { "displayName": "Debi K." },
      "scrapedAt": "2026-06-26T13:00:00.000Z"
    }
  ]
}
```

***

### How to Use

1. Open the Actor page on Apify Store and click **Try for free**.
2. Paste one or more Seed.com product URLs into the **Product URLs** field.
3. Set `maxNumberOfReviews` to limit results, or leave at `0` for all reviews.
4. Optionally set a `targetDate` to pull only reviews from a specific period.
5. Click **Start**. The actor fetches each product page, then paginates through reviews automatically.
6. When the run completes, open the **Dataset** tab and export as JSON, CSV, or Excel.

> **Finding product URLs:** Navigate to any product on [seed.com](https://seed.com) — the DS-01® Daily Synbiotic, PM-02™ Sleep + Restore, DM-02™ Daily Multivitamin, etc. — and copy the URL from your browser.

***

### Use Cases

- **Competitive intelligence** — Track what customers say about Seed's probiotics and synbiotics, identify recurring complaints, and find positioning gaps for your own health & wellness brand.
- **Sentiment analysis** — Feed reviews into an NLP pipeline to measure sentiment trends over time, e.g. before and after a probiotic formula change or a new product launch.
- **Marketing research** — Discover the exact language real customers use to describe gut health benefits, then use it to write ad copy, landing pages, and emails that convert.
- **Academic & health research** — Collect consumer-reported outcomes for probiotic and synbiotic supplements at scale for clinical literature reviews, microbiome research, or regulatory analysis.
- **Brand monitoring** — Schedule recurring runs to track new reviews weekly and catch rating changes as Seed releases new products or updates existing formulas.

***

### Advanced Tips

#### Scheduling recurring runs

Use Apify's **Schedules** feature to run this actor weekly or monthly. Set `targetDate` to your last run date to collect only new reviews each time — no deduplication needed.

#### Exporting to Google Sheets

Connect the dataset output to **Apify's Google Sheets integration** (under Integrations) to automatically populate a spreadsheet after each run.

#### Filtering for higher-quality signal

Filter `verifiedBuyer: true` downstream to focus on confirmed purchasers. The `sentiment` field (0–1 float) and `score` field (1–5 integer) are both ready to use directly in pandas, Tableau, or Power BI.

#### Proxies for production runs

No proxy is needed for single-product runs. For high-frequency or large multi-product batches, enable **Apify Residential Proxies** via `proxyConfiguration` to avoid throttling.

***

### FAQ & Troubleshooting

**Do I need a Seed.com account or API key?**
No. The actor only accesses publicly visible data — no login, cookies, or credentials required.

**How many reviews can I scrape?**
Seed.com has thousands of reviews across all products. Each product page shows its own count (available in the output as `yotpoTotalReviews`). Free users are limited to 50 reviews per product per run.

**The actor returned fewer reviews than expected — why?**
Check `yotpoTotalReviews` in the output. If your result is lower, try removing the `targetDate` filter or increasing `maxNumberOfReviews`. Also verify the product URL resolves correctly in a browser.

**Can I scrape multiple products in one run?**
Yes — add multiple URLs to `startUrls`. Each product is processed in sequence and appears as a separate dataset item.

**Will this break if Seed.com updates their site?**
The actor reads from Seed's structured `__NEXT_DATA__` JSON (embedded in the page HTML) and their internal review API — both are stable interfaces. Any breaking changes will be patched quickly.

**Is scraping Seed.com legal?**
This actor only accesses publicly visible data. Always review Seed.com's Terms of Service and ensure your intended use complies with applicable laws and platform policies.

***

### Support

- 📬 **Email:** <me@ahmedhrid.com>
- 🐛 **Bug reports:** Open an issue via the **Issues** tab on this Actor page
- 💬 **Questions:** Use the Actor's **Discussion** section on Apify Store

Response time: typically within 24–48 hours.

# Actor input Schema

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

One or more seed.com product page URLs (e.g. https://seed.com/daily-multivitamin).

## `maxNumberOfReviews` (type: `integer`):

Maximum reviews to scrape per product. 0 = all available (paid users only — free users capped at 50).

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

Field to sort reviews by.

## `ascending` (type: `boolean`):

Sort ascending. Default false = newest/highest first.

## `targetDate` (type: `string`):

Only include reviews created on or after this date (YYYY-MM-DD). Leave empty for all.

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

Residential proxies recommended for large runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://seed.com/daily-synbiotic"
    }
  ],
  "maxNumberOfReviews": 0,
  "sortBy": "date",
  "ascending": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Each item is a review with fields: reviewId, productId, productName, score, title, content, sentiment, verifiedBuyer, createdAt, language, topics, votesUp, votesDown, author, customFields, scrapedAt.

# 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 = {
    "startUrls": [
        {
            "url": "https://seed.com/daily-synbiotic"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/seed-product-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 = {
    "startUrls": [{ "url": "https://seed.com/daily-synbiotic" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/seed-product-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 '{
  "startUrls": [
    {
      "url": "https://seed.com/daily-synbiotic"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call reviewly/seed-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seed Product Reviews Scraper",
        "description": "Scrapes all customer reviews from seed.com with filtering by date, topic, and sort order.",
        "version": "0.0",
        "x-build-id": "RP9kwrg8vNmNgab1y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~seed-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-seed-product-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/reviewly~seed-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-seed-product-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/reviewly~seed-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-seed-product-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "One or more seed.com product page URLs (e.g. https://seed.com/daily-multivitamin).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxNumberOfReviews": {
                        "title": "Max reviews per product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum reviews to scrape per product. 0 = all available (paid users only — free users capped at 50).",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "date",
                            "score",
                            "relevant"
                        ],
                        "type": "string",
                        "description": "Field to sort reviews by.",
                        "default": "date"
                    },
                    "ascending": {
                        "title": "Ascending order",
                        "type": "boolean",
                        "description": "Sort ascending. Default false = newest/highest first.",
                        "default": false
                    },
                    "targetDate": {
                        "title": "Filter reviews after date",
                        "type": "string",
                        "description": "Only include reviews created on or after this date (YYYY-MM-DD). Leave empty for all."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies recommended for large runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
