# Facebook Reviews Scraper — No Login (`reviewly/facebook-reviews-scraper`) Actor

Extract reviews from any public Facebook page without an account, cookies, or browser. Clean JSON: reviewer, recommendation, text, date, photos

- **URL**: https://apify.com/reviewly/facebook-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.40 / 1,000 reviews

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

## Facebook Reviews Scraper — Extract Page Reviews & Recommendations Without Login

**Scrape Facebook page reviews in seconds — no Facebook account, no cookies, no browser automation. Just paste a page URL and get clean, structured review data.**

- ⚡ **Fast & lightweight** — pure HTTP scraping, no headless browser overhead
- 🔓 **No login required** — zero risk to any Facebook account, no session cookies to maintain
- 📦 **Clean JSON output** — reviewer, recommendation, review text, date, reactions, comments, photos, permalink
- 🎯 **Works with any public Facebook page** — restaurants, hotels, local businesses, services, brands

---

### 📌 What This Actor Does

The **Facebook Reviews Scraper** is an [Apify Actor](https://apify.com/store) that extracts reviews (Facebook calls them *recommendations*) from any **public Facebook page** — the same reviews you see on a page's "Reviews" tab.

You give it one or more Facebook page URLs. It returns a structured dataset with the page's overall rating summary and every publicly visible review: who wrote it, whether they recommend the business, the full review text, the date, engagement counts, and attached photos.

**Who it's for:**

- **Marketers & agencies** monitoring brand reputation across client pages
- **Business owners** tracking their own (and competitors') customer feedback
- **Data analysts & researchers** studying customer sentiment at scale
- **Developers** who need Facebook review data in their apps, dashboards, or pipelines without touching the Facebook API

No coding is required to run it — but the output plugs straight into any workflow via the Apify API, webhooks, or integrations (Google Sheets, Zapier, Make, and more).

---

### ✨ Key Features

- **No authentication** — scrapes the public, logged-out reviews surface. You never provide a Facebook account, so there is nothing to get banned.
- **Complete review records** — reviewer name and profile link, recommends yes/no, review text, ISO date, reaction count, comment count, photo URLs, and a direct permalink to the original post.
- **Page-level summary included** — overall recommendation percentage and total review count (e.g. *"94% recommend (202 reviews)"*).
- **Multiple pages per run** — pass a list of page URLs and get one dataset item per page.
- **Flexible URL input** — accepts `facebook.com/YourPage`, the `/reviews` tab URL, or `profile.php?id=...` links. The Actor normalizes them automatically.
- **Smart filtering** — cap total reviews with `maxReviews`, or skip reviews older than a `targetDate`.
- **Built-in resilience** — automatic proxy rotation and retries when Facebook shows a login wall to a flagged IP.
- **Export anywhere** — download results as JSON, CSV, Excel, or XML, or pull them through the Apify API.

---

### 🧠 Why This Actor Is Different

Most Facebook scrapers drive a full headless browser and often require you to supply session cookies from a real account — slow, fragile, and risky.

This Actor talks to Facebook the same way your browser does, but at the HTTP level:

- **No account risk.** It never logs in, so there are no cookies to refresh and no account that can be flagged.
- **Faster and cheaper.** Without a browser, runs use a fraction of the memory and compute — a page's reviews are collected in seconds.
- **Honest about limits.** Facebook only shows part of a page's review history to logged-out visitors (typically the ~50–65 most relevant reviews). This Actor tells you exactly when that limit is reached instead of silently stopping — see the FAQ below.
- **Self-healing configuration.** If Facebook rotates its internal query ID, you can update it with a single environment variable — no redeploy, no waiting for a fix.

---

### ⚙️ Input Configuration

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | **Required.** Facebook page URLs to scrape. Any format works: `https://www.facebook.com/YourPage`, `https://www.facebook.com/YourPage/reviews`, or `https://www.facebook.com/profile.php?id=123456789`. |
| `maxReviews` | integer | Maximum total reviews to collect across all pages. `0` = no limit (default). |
| `targetDate` | string | Optional ISO date (e.g. `2024-01-01`). Reviews older than this are skipped. |
| `proxyConfiguration` | object | Proxy settings. **Residential proxies are strongly recommended** (default). |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/copperkettleyqr" },
    { "url": "https://www.facebook.com/anotherbusiness/reviews" }
  ],
  "maxReviews": 100,
  "targetDate": "2023-01-01",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

**Tips for best results:**

- Keep the default **residential proxy** setting — Facebook shows a login wall to datacenter IPs far more often.
- `targetDate` filters rather than stops: Facebook orders reviews by relevance, not date, so the Actor keeps paginating and drops the old ones.
- Use the page's main URL if you're unsure — the Actor finds the reviews tab itself.

***

### 📤 Output Format

One dataset item per Facebook page:

```json
{
  "name": "The Copper Kettle Restaurant",
  "pageId": "100064027242849",
  "url": "https://www.facebook.com/copperkettleyqr/reviews",
  "recommendPercent": 94,
  "reviewCount": 202,
  "reviews": [
    {
      "id": "8188651441177333",
      "reviewerName": "Karen K.",
      "reviewerId": "pfbid0BR5BDMWng...",
      "reviewerUrl": "https://www.facebook.com/karen.k",
      "recommends": true,
      "text": "Excellent experience for a group of 45! From the point of booking to the service to the meals everything was great!",
      "date": "2022-09-25T22:05:34.000Z",
      "reactionCount": 2,
      "commentCount": 3,
      "photos": ["https://scontent.xx.fbcdn.net/..."],
      "permalink": "https://www.facebook.com/karen.k/posts/pfbid06HUV..."
    }
  ]
}
```

**Field reference:**

| Field | Meaning |
|---|---|
| `name` / `pageId` / `url` | The Facebook page's name, numeric ID, and reviews URL |
| `recommendPercent` | Overall recommendation score shown on the page (e.g. `94`) |
| `reviewCount` | Total reviews the page claims (see FAQ on visibility) |
| `reviews[].recommends` | `true` = recommends, `false` = doesn't recommend (Facebook reviews have no star ratings since 2018) |
| `reviews[].text` | Full review text (`null` for recommendations without text) |
| `reviews[].date` | ISO 8601 timestamp of the review |
| `reviews[].reactionCount` / `commentCount` | Engagement on the review post |
| `reviews[].photos` | URLs of photos attached to the review |
| `reviews[].permalink` | Direct link to the original review post |

***

### ▶️ How to Use

1. **Open the Actor** in the Apify Store and click **Try for free**.
2. **Paste your Facebook page URL(s)** into the *Facebook page URLs* field.
3. *(Optional)* Set `maxReviews` or `targetDate` to limit the crawl.
4. Click **Start**. A typical page finishes in under a minute.
5. **Download your data** from the *Storage* tab — JSON, CSV, Excel, or XML — or connect it to Google Sheets, Zapier, Make, or your own code via the Apify API.

**Common workflow — scheduled monitoring:** create a Task with your page URLs, add a weekly schedule, and attach a webhook or Google Sheets integration. You'll have an always-fresh review feed with zero manual work.

***

### 📈 Use Cases

- **Reputation monitoring** — track new positive/negative recommendations for your brand's pages and alert your team when a negative review lands.
- **Competitor analysis** — compare recommendation percentages and review sentiment across competing local businesses in your market.
- **Lead generation & sales intelligence** — identify unhappy customers of competitors, or businesses with poor review responses that need reputation-management services.
- **Market research & NLP** — build datasets of real customer feedback for sentiment analysis, topic modeling, or training data.
- **Agency reporting** — pull weekly review data for every client page into one automated dashboard instead of checking pages by hand.

***

### 🛠️ Advanced Tips

- **Proxies:** the default Apify **RESIDENTIAL** group is the right choice. If you see repeated *"login wall"* retries in the log, your proxy group is being flagged — switch to residential.
- **Scaling:** batch many page URLs into a single run (one dataset item each) rather than one run per page — it's faster and cheaper.
- **Rate of collection:** Facebook serves ~3 reviews per internal request; the Actor paginates automatically with polite delays. A 60-review page takes roughly 20–30 seconds.
- **`DOC_ID` environment variable:** the Actor pins Facebook's internal GraphQL query ID. If Facebook ever rotates it (pagination would stop working), set the new value as the `DOC_ID` env var in the Actor's settings — no redeploy needed.

***

### ❓ FAQ / Troubleshooting

**Why do I get ~65 reviews when the page says it has 200+?**
Facebook only exposes a page's most relevant reviews (typically 50–65) to visitors who aren't logged in. This is a Facebook-side limit, not a scraper bug — the Actor logs `Facebook ended pagination at X of Y` when it happens. The remaining reviews are only visible to logged-in users, which this Actor deliberately avoids to keep your usage account-free and safe.

**Why are there no star ratings?**
Facebook replaced star ratings with binary recommendations in 2018. The `recommends` field (`true`/`false`) is the rating, and `recommendPercent` is the page-level score.

**The run says "blocked every IP" — what do I do?**
Your proxy IPs are getting Facebook's login wall. Make sure `proxyConfiguration` uses the **RESIDENTIAL** group, then re-run. The Actor already retries 5 fresh IPs per page automatically.

**A URL returns "404 — no reviews tab".**
That page either doesn't exist or has reviews disabled. Pages with reviews turned off return an empty result by design.

**Can it scrape personal profiles or groups?**
No — only public **pages** with a Reviews tab (businesses, restaurants, services, etc.).

**Is this legal?**
The Actor only accesses publicly available data, without logging in or bypassing any authentication. As with any web scraping, you are responsible for using the data in compliance with applicable laws and regulations (e.g. GDPR) in your jurisdiction.

***

### 📞 Support

- **Issues & feature requests:** open an issue on the Actor's **Issues** tab in the Apify Console
- **Direct contact:** <me@ahmedhrid.com>

Found it useful? A ⭐ rating in the Apify Store helps others discover the Actor and keeps development going.

# Actor input Schema

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

Facebook page URLs to scrape reviews from — e.g. https://www.facebook.com/copperkettleyqr, its /reviews tab, or a profile.php?id=... URL.

## `maxReviews` (type: `integer`):

Maximum total number of reviews to collect across all pages. 0 = no limit.

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

ISO date (e.g. 2024-01-01). Reviews older than this are skipped. Note: Facebook orders reviews by relevance, not date, so this filters rather than stopping pagination early.

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

Residential proxies are recommended — Facebook shows a login wall to flagged/datacenter IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/copperkettleyqr/reviews"
    }
  ],
  "maxReviews": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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://www.facebook.com/copperkettleyqr/reviews"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/facebook-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://www.facebook.com/copperkettleyqr/reviews" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reviews Scraper — No Login",
        "description": "Extract reviews from any public Facebook page without an account, cookies, or browser. Clean JSON: reviewer, recommendation, text, date, photos",
        "version": "0.0",
        "x-build-id": "4UCRD6PmCJyrmPcDp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~facebook-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-facebook-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~facebook-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-facebook-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~facebook-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-facebook-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": "Facebook page URLs",
                        "type": "array",
                        "description": "Facebook page URLs to scrape reviews from — e.g. https://www.facebook.com/copperkettleyqr, its /reviews tab, or a profile.php?id=... URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total number of reviews to collect across all pages. 0 = no limit.",
                        "default": 0
                    },
                    "targetDate": {
                        "title": "Oldest review date",
                        "type": "string",
                        "description": "ISO date (e.g. 2024-01-01). Reviews older than this are skipped. Note: Facebook orders reviews by relevance, not date, so this filters rather than stopping pagination early."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are recommended — Facebook shows a login wall to flagged/datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
