# Faire Wholesale Product Scraper (`parseforge/faire-scraper`) Actor

Browse Faire by keyword and pull every matching wholesale product with its name, brand, retail price, minimum order quantity, and brand rating. Each item includes the image, review count, and origin country. Handy for retail sourcing, assortment research, and price benchmarking.

- **URL**: https://apify.com/parseforge/faire-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 91.1% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.80 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛍️ Faire Wholesale Scraper

> 🚀 **Export thousands of wholesale products in seconds.** A single search like "candles" returns 1,232 live products across 21 pages, each with brand, retail price, minimum order data, and ratings.

> 🕒 **Last updated:** 2026-06-02 · **📊 25 fields** per record · 60 products per page · US wholesale marketplace coverage

Faire is the wholesale marketplace where thousands of independent brands sell to retailers. This Actor turns any Faire product search into a clean, structured dataset: product names, images, retail prices, brand details, minimum order quantities, and brand review ratings, ready for CSV, Excel, JSON, or your own pipeline.

**Coverage:** any public Faire product search. Pass one or more search terms (for example "candles", "leather wallet", "ceramic mugs") and the Actor paginates the full result set for you, pulling brand metadata for every product.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Independent retailers and buyers | Source new brands and products to stock |
| Brands and wholesalers | Monitor competitor catalogs and pricing |
| Market researchers | Track assortment, trends, and brand ratings |
| Dropshippers and resellers | Build product feeds with retail price anchors |

### 📋 What the Faire Wholesale Scraper does

- Runs any number of product search terms against Faire's public catalog.
- Paginates every result set (60 products per page) up to your item limit.
- Returns 25 structured fields per product, including brand profile data.
- Captures retail (MSRP) price, minimum order quantity, and brand review ratings.
- Outputs an image gallery URL list for every product.
- Exports to CSV, Excel, JSON, XML, or via API.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | One or more product queries to run on Faire. One result set per term. |
| `maxItems` | integer | Cap on total products returned. Free plan is limited to 10 (preview). |

**Example 1: single search**
```json
{
  "searchTerms": ["candles"],
  "maxItems": 100
}
````

**Example 2: multiple searches**

```json
{
  "searchTerms": ["leather wallet", "ceramic mugs", "scented candles"],
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** Faire shows **retail (MSRP) pricing** to logged-out visitors. Wholesale (trade) prices are gated behind a retailer login and are not collected. Every other field below is fully public.

### 📊 Output

Each record contains the following fields:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Primary product image |
| 📌 `name` | Product name |
| 🔗 `productUrl` | Direct link to the product on Faire |
| 🆔 `productToken` | Faire product identifier |
| 🏷 `brandName` | Brand selling the product |
| 🆔 `brandToken` | Faire brand identifier |
| 🔗 `brandUrl` | Direct link to the brand page |
| 💲 `retailPrice` | Retail (MSRP) price |
| 💱 `currency` | Price currency |
| 📦 `minOrderQuantity` | Per-style minimum order quantity |
| 💰 `brandMinOrderAmount` | Brand minimum order amount |
| ⭐ `brandRating` | Average brand review rating |
| 🗣 `brandReviewCount` | Number of brand reviews |
| 🆕 `isNew` | New product flag |
| 🔥 `isBestSeller` | Best seller flag |
| 🏆 `isTopShop` | Top Shop brand flag |
| 📍 `state` | Product availability state |
| 🌍 `basedInCountry` | Product origin country |
| 🚚 `shipsFromCountry` | Brand shipping country |
| 🧮 `brandActiveProducts` | Active product count for the brand |
| 🖼 `brandImageUrl` | Brand profile image |
| 🔎 `searchTerm` | The query that surfaced this product |
| 🖼 `images` | Full image gallery URLs |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Error message, null on success |

**Real sample records:**

```json
{
  "imageUrl": "https://cdn.faire.com/fastly/19d864ffd0ffaad9d41e5f7fc7736f33b224e51fc38312ddb822f8de3ec8637f.jpeg?format=jpg",
  "name": "8oz Mason Jar Soy Candles - Rustic Lid - 6 Pack No Label",
  "productUrl": "https://www.faire.com/product/p_y6c6r46bes",
  "brandName": "Heavenly Scents",
  "brandUrl": "https://www.faire.com/brand/b_1uqiazbote",
  "retailPrice": 10,
  "currency": "USD",
  "minOrderQuantity": 0,
  "brandMinOrderAmount": 0,
  "brandRating": 4.9,
  "brandReviewCount": 171,
  "isTopShop": true,
  "basedInCountry": "USA",
  "brandActiveProducts": 71,
  "scrapedAt": "2026-06-02T16:41:35.438Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://cdn.faire.com/fastly/28209b99f6647c8e7c01e6881d544d52e3b26e4687d50f23231f25b223b29d73.jpeg?format=jpg",
  "name": "Aesthetic Candle Jar | Cork Lids Unbranded",
  "productUrl": "https://www.faire.com/product/p_f8rt6s5g5d",
  "brandName": "Candleglambyperry",
  "brandUrl": "https://www.faire.com/brand/b_2ee6drsyej",
  "retailPrice": 25,
  "currency": "USD",
  "brandMinOrderAmount": 75,
  "brandRating": 5,
  "brandReviewCount": 30,
  "isTopShop": true,
  "basedInCountry": "USA",
  "brandActiveProducts": 47,
  "scrapedAt": "2026-06-02T16:41:35.512Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://cdn.faire.com/fastly/1e01e916f34e69bebbb356c90ce04c0ec46bb027630fdf0a9e972d55ec43877c.jpeg?format=jpg",
  "name": "Soy Wax Candle, Jar Candles, Soy Non-Toxic Candles",
  "productUrl": "https://www.faire.com/product/p_9wtqum5a5s",
  "brandName": "The Freckled Wood Co.",
  "brandUrl": "https://www.faire.com/brand/b_9zb3e3jpfn",
  "retailPrice": 17,
  "currency": "USD",
  "brandMinOrderAmount": 100,
  "brandRating": 4.9,
  "brandReviewCount": 65,
  "isBestSeller": true,
  "basedInCountry": "USA",
  "brandActiveProducts": 13,
  "scrapedAt": "2026-06-02T16:41:35.541Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Real catalog scale.** One term ("candles") returns over 1,200 live products. The Actor paginates all of them.
- **Brand intelligence built in.** Every product carries its brand rating, review count, active product count, and Top Shop status.
- **Clean pricing anchors.** Retail (MSRP) price and currency on every record, with no always-null fields.
- **No browser needed.** Lightweight and fast, so runs stay cheap.
- **Ready to export.** CSV, Excel, JSON, XML, or API, with a tidy table view out of the box.

### 📈 How it compares to alternatives

| | Faire Wholesale Scraper | Manual browsing | Generic web scrapers |
|---|---|---|---|
| Structured 25-field output | ✅ | ❌ | ⚠️ Needs setup |
| Brand ratings and review counts | ✅ | ⚠️ Per page | ❌ |
| Full pagination | ✅ | ❌ | ⚠️ |
| Bulk multi-term search | ✅ | ❌ | ⚠️ |
| Export to CSV/Excel/JSON/XML | ✅ | ❌ | ⚠️ |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Faire Wholesale Scraper.
3. Enter one or more `searchTerms` and set `maxItems`.
4. Click **Start** and watch the dataset fill in real time.
5. Export your results as CSV, Excel, JSON, or XML, or pull them via API.

### 💼 Business use cases

**🛒 Retail sourcing**
| Goal | How |
|---|---|
| Discover new brands | Search a category and sort by rating |
| Compare retail prices | Pull MSRP across competing products |

**📊 Competitor monitoring**
| Goal | How |
|---|---|
| Track a niche | Re-run searches on a schedule |
| Watch brand momentum | Follow review counts over time |

**📈 Market research**
| Goal | How |
|---|---|
| Map assortment | Aggregate products across many terms |
| Spot best sellers | Filter on the best seller flag |

**🎁 Product feed building**
| Goal | How |
|---|---|
| Build catalogs | Export image galleries and names |
| Anchor pricing | Use retail price as a baseline |

### 🔌 Automating Faire Wholesale Scraper

Connect this Actor to your stack with Apify integrations: **Make**, **Zapier**, **Slack**, **Airbyte**, **GitHub**, and **Google Drive**. Trigger runs on a schedule and push fresh wholesale data straight into your spreadsheets, databases, or notifications.

### 🌟 Beyond business use cases

- **Research:** study pricing and assortment patterns in independent retail.
- **Personal:** find unique products and makers to support.
- **Non-profit:** source ethically made goods from small brands.
- **Experimentation:** build datasets for analytics and ML projects.

### 🤖 Ask an AI assistant

Paste your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask it to summarize top brands, average pricing, or category trends.

### ❓ Frequently Asked Questions

**1. Does this collect wholesale (trade) prices?**
No. Faire gates wholesale pricing behind a retailer login. The Actor collects the public retail (MSRP) price instead.

**2. How many products can I get per search?**
As many as Faire returns. "candles" yields 1,232 across 21 pages. Use `maxItems` to cap output.

**3. Can I search multiple terms in one run?**
Yes. Pass an array of `searchTerms` and the Actor processes each one.

**4. What fields are included?**
25 fields per product, including brand rating, review count, MOQ, and an image gallery.

**5. Do I need a Faire account?**
No. The Actor only uses publicly available data.

**6. What export formats are supported?**
CSV, Excel, JSON, XML, and API.

**7. How fresh is the data?**
Every run pulls live data at the moment it executes.

**8. Are brand ratings included?**
Yes, both the average brand rating and the total review count.

**9. Can I run it on a schedule?**
Yes, with Apify Schedules and integrations.

**10. Is there a free option?**
Yes. Free runs are limited to 10 items as a preview. Paid plans unlock up to 1,000,000.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and 5,000-plus integrations to push Faire data into Make, Zapier, Google Sheets, Airtable, databases, and more.

### 🔗 Recommended Actors

- [AliExpress Scraper](https://apify.com/parseforge/aliexpress-scraper)
- [IndiaMART Scraper](https://apify.com/parseforge/indiamart-scraper)
- [Made-in-China Scraper](https://apify.com/parseforge/made-in-china-scraper)
- [Etsy Scraper](https://apify.com/parseforge/etsy-scraper)
- [ThomasNet Scraper](https://apify.com/parseforge/thomasnet-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Faire. Only publicly available data is collected.

# Actor input Schema

## `searchTerms` (type: `array`):

Product search queries to run on Faire (e.g. "candles", "leather wallet"). One result set per term.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

## Actor input object example

```json
{
  "searchTerms": [
    "candles"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "searchTerms": [
        "candles"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/faire-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 = {
    "searchTerms": ["candles"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/faire-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 '{
  "searchTerms": [
    "candles"
  ],
  "maxItems": 10
}' |
apify call parseforge/faire-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Faire Wholesale Product Scraper",
        "description": "Browse Faire by keyword and pull every matching wholesale product with its name, brand, retail price, minimum order quantity, and brand rating. Each item includes the image, review count, and origin country. Handy for retail sourcing, assortment research, and price benchmarking.",
        "version": "0.1",
        "x-build-id": "5xdicRRBRxq6hENTP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~faire-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-faire-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/parseforge~faire-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-faire-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/parseforge~faire-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-faire-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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "minItems": 1,
                        "type": "array",
                        "description": "Product search queries to run on Faire (e.g. \"candles\", \"leather wallet\"). One result set per term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
