# Facebook Page Reviews Scraper (`igview-owner/facebook-page-reviews-scraper`) Actor

Scrape Facebook page reviews in minutes. Extract ratings, review text, author details, reactions, tags and sentiment from public pages. Perfect for reputation monitoring, competitor analysis, and customer feedback reports.

- **URL**: https://apify.com/igview-owner/facebook-page-reviews-scraper.md
- **Developed by:** [Sachin Kumar Yadav](https://apify.com/igview-owner) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

This Actor is paid per result. You are not charged for the Apify platform usage, but only a fixed price for dataset items the Actor outputs.
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-result

## 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 Page Reviews Scraper – Extract All Page Reviews Fast

**Scrape customer reviews, ratings, and feedback from public Facebook pages using only the page ID. Perfect for reputation monitoring, sentiment analysis, customer feedback collection, and competitive research.**

### 📋 Table of Contents

- [🚀 Features](#-features)
- [🎯 Use Cases](#-use-cases)
- [⚡ Quick Start](#-quick-start)
- [📊 Input Parameters](#-input-parameters)
- [📤 Output Format](#-output-format)
- [📈 Data Fields Explained](#-data-fields-explained)
- [🔧 Performance & Reliability](#-performance--reliability)
- [💡 Best Practices](#-best-practices)
- [❓ FAQ](#-faq)
- [📞 Support](#-support)

### 🚀 Features

#### **Comprehensive Review Extraction**
- ✅ **Review Content** – Get complete review messages and feedback
- ✅ **Author Details** – Extract author name, ID, profile picture, and URL
- ✅ **Recommendation Status** – Know if the reviewer recommends the page
- ✅ **Engagement Metrics** – Reactions count, share count for each review
- ✅ **Review Tags** – Capture tags like "Child-friendly", "Poor presentation", etc.
- ✅ **ID-Based Targeting** – Uses numeric Facebook page IDs only
- ✅ **No Login Required** – Works on public pages without Facebook login

#### 🎨 **Batch & Limits Control**
- ✅ **Batch Processing** – Process multiple page IDs in one run (up to 100)
- ✅ **Max Reviews Per Page** – Control how many reviews to scrape per page (1-1000)
- ✅ **Auto Pagination** – Automatically follows cursor until `maxReviews` or no more reviews
- ✅ **Rate Limiting** – Built‑in delay between API calls to avoid throttling

#### 🔧 **Robust & Production Ready**
- ✅ **Clear Errors** – Pushes error entries to dataset when a page fails
- ✅ **Clean Output** – Simple, flat JSON records – one item per review
- ✅ **Timestamp Tracking** – Each review includes `scraped_at` timestamp

### 🎯 Use Cases

| Use Case | Description | Benefits |
|----------|-------------|----------|
| **Reputation Monitoring** | Track customer reviews and ratings | Monitor brand reputation in real-time |
| **Sentiment Analysis** | Analyze positive and negative feedback | Understand customer sentiment and satisfaction |
| **Competitive Research** | Collect reviews from competitor pages | Benchmark against competitors and identify gaps |
| **Customer Feedback** | Gather authentic customer opinions | Improve products/services based on real feedback |
| **Review Management** | Export reviews for reporting and analysis | Create comprehensive review reports for stakeholders |
| **Dataset Creation** | Build datasets of customer reviews | Use for ML training, sentiment models, or NLP |

### ⚡ Quick Start

#### 1️⃣ Single Page Reviews Scraping
```json
{
  "pageIds": [
    "100064718047398"
  ],
  "maxReviews": 100
}
````

#### 2️⃣ Multiple Pages (Batch Processing)

```json
{
  "pageIds": [
    "100064718047398",
    "100088509573446"
  ],
  "maxReviews": 500
}
```

### 📊 Input Parameters

#### Configuration Options

| Parameter   | Type    | Required | Description |
|------------|---------|----------|-------------|
| `pageIds`  | Array   | ✅       | List of **numeric** Facebook page IDs (1–100) |
| `maxReviews`| Integer | ✅       | Max reviews to scrape **per page** (1–1000) |

#### 📝 Details

**pageIds** (Required)

- Array of **numeric** Facebook page IDs as strings.
- Facebook **URLs are not allowed** – only IDs.
- Example IDs:
  - `"100064718047398"`
  - `"100088509573446"`
- Minimum: 1 ID
- Maximum: 100 IDs per run
- Non‑numeric values are rejected with a clear error.

**maxReviews** (Required)

- Integer between **1** and **1000**.
- Controls **maximum number of reviews per page**.
- The actor automatically paginates until:
  - `maxReviews` is reached, or
  - API returns no more reviews.

### 📤 Output Format

#### ⭐ **Review Record Example**

Each item in the dataset represents **one review**:

```json
{
  "page_id": "100064718047398",
  "post_id": "10162985174226355",
  "type": "review",
  "recommend": true,
  "message": "Always pleasant girls and guys!!!",
  "author_id": "pfbid02UB8y2hToHQWjZQ9JjeuYTTyZ7VkoDZUVmS7Pnv1Kj5rG4uxCtqsxnRkJeWs34YyNl",
  "author_name": "Debra Stephen",
  "author_url": null,
  "author_profile_picture": "https://scontent.fbah6-1.fna.fbcdn.net/v/t39.30808-1/468283803_10161722413746355_5405649237911037793_n.jpg?...",
  "reactions_count": 0,
  "share_count": 0,
  "photos": [],
  "tags": ["Child-friendly"],
  "scraped_at": "2024-11-30T06:21:00.000Z"
}
```

### 📈 Data Fields Explained

#### 📊 **Review Fields Reference**

| Field       | Type    | Description |
|------------|---------|-------------|
| `page_id`  | String  | Numeric Facebook page ID the review belongs to |
| `post_id` | String  | Unique post ID of the review on Facebook |
| `type` | String| Type of content (usually `"review"`) |
| `recommend`| Boolean  | Whether the reviewer recommends the page (true/false) |
| `message`| String  | The review message/feedback text |
| `author_id`| String  | Unique ID of the review author |
| `author_name`| String  | Name of the review author |
| `author_url`| String  | URL to author's profile (if available) |
| `author_profile_picture`| String  | URL to author's profile picture |
| `reactions_count`| Number  | Number of reactions on the review |
| `share_count`| Number  | Number of times the review was shared |
| `photos`| Array  | Array of photo URLs attached to the review |
| `tags`| Array  | Tags associated with the review (e.g., "Child-friendly") |
| `scraped_at`| String  | ISO timestamp when the review was scraped |

### 🔧 Performance & Reliability

#### ⚡ **Speed & Efficiency**

| Metric | Performance | Details |
|--------|-------------|----------|
| **Processing Speed** | Fast | Depends on number of reviews and pages |
| **Batch Processing** | 1–100 page IDs | Process multiple pages in one run |
| **Rate Limiting** | ~2 seconds | Delay between pagination and pages |

#### 🔄 **Reliability Features**

- ✅ **Auto‑Retry Logic** – Retries failed API requests with delays
- ✅ **Error Reporting** – Pushes error objects (status, error, errorCode) to dataset
- ✅ **Graceful Failures** – Continues with other pages even if one fails

### 💡 Best Practices

#### ✅ Recommended Usage

1. **Test with a single page ID first** – Verify the output structure and review count.
2. **Use correct numeric IDs** – Make sure you are using the correct page ID, not the URL.
3. **Tune `maxReviews`** – Start small (e.g., 50–100) and increase if needed.
4. **Monitor dataset views** – Use the **Reviews Overview**, **Detailed Reviews**, and **Sentiment Analysis** views in Apify UI.
5. **Check API limits** – If you see many 429 errors, lower concurrency or run less frequently.
6. **Analyze sentiment** – Use the `recommend` field and `tags` to understand customer sentiment.

#### ⚠️ **Important Notes**

- Only **public Facebook pages** can be used.
- **Private or restricted content** will not be accessible.
- Maximum **100 page IDs** per run (based on input schema).
- Maximum **1000 reviews per page** can be scraped.
- Rate limiting is applied automatically between requests.

### ❓ FAQ

#### **Q: Do I need a Facebook account to use this actor?**

**A:** No. The actor uses a Facebook API and works only with public pages.

#### **Q: Can I scrape reviews from private Facebook pages?**

**A:** No. Only public content is accessible.

#### **Q: What if a page doesn't have reviews?**

**A:** The actor will complete successfully but return an empty dataset or minimal results. No errors will be thrown.

#### **Q: Can I process multiple pages in one run?**

**A:** Yes. You can pass up to 100 numeric page IDs in `pageIds`.

#### **Q: Does this actor return page details like followers and contact info?**

**A:** No. This actor is focused **only on reviews**. For full page details, use a dedicated "Page Details" actor.

#### **Q: What happens if one page fails?**

**A:** The actor continues processing other IDs. Failures are stored as error records in the dataset.

#### **Q: Can I analyze sentiment from the reviews?**

**A:** Yes! Use the `recommend` field (true/false) and `tags` array to understand sentiment. You can also analyze the `message` text using NLP tools.

#### **Q: Is this legal and compliant?**

**A:** This tool works only with publicly available content. You are responsible for complying with Facebook's Terms of Service and all applicable laws.

#### **Q: How often can I run this actor?**

**A:** As often as needed, within your API and Apify usage limits.

### 📞 Support

#### 🆘 **Need Help?**

- 📧 **Issues** – Report bugs and request features on the actor page
- 📖 **Documentation** – Use this README as reference for input/output
- 🎯 **Best Practices** – Follow recommendations above for stable runs
- 💬 **Community** – Join Apify Discord for extra help

***

### 🔗 Related Scrapers

- [Facebook Page Photos Downloader](https://apify.com/igview-owner/facebook-page-photos-downloader) - Download photos from Facebook pages
- [Facebook Page Video Downloader](https://apify.com/igview-owner/facebook-page-video-downloader) - Download videos from Facebook pages
- [Facebook Page Details Extractor](https://apify.com/igview-owner/facebook-page-details-extractor) - Extract details from Facebook pages
- [Facebook Page Reels Extractor](https://apify.com/igview-owner/facebook-page-reels-extractor) - Extract reels from Facebook pages
- [Facebook Marketplace Data Scraper](https://apify.com/igview-owner/facebook-marketplace-data-scraper) - Scrape Facebook Marketplace data
- [Facebook Media Downloader](https://apify.com/igview-owner/facebook-media-downloader) - Download photos and videos from Facebook
- [Facebook Old Posts Search](https://apify.com/igview-owner/facebook-old-posts-search) - Search for old posts on Facebook
- [Facebook Page Details Scraper](https://apify.com/igview-owner/facebook-page-details-scraper) - Scrape Facebook page details

***

### 🏷️ **Find ME**

`facebook reviews`, `facebook review scraper`, `facebook page reviews`, `facebook ratings`, `facebook feedback`, `facebook scraper`, `facebook review extractor`, `facebook page reviews scraper`, `apify facebook reviews`, `facebook sentiment analysis`, `facebook customer feedback`, `facebook reputation monitoring`, `facebook dataset`, `social media reviews`, `customer reviews`, `facebook page id`, `review scraper facebook`, `facebook review downloader`, `best facebook review scraper`, `extract facebook reviews`, `facebook testimonials`, `facebook ratings scraper`

***

### 🚀 **Get Started Now**

**Ready to scrape Facebook page reviews?**

1. Click ["Try for free"](https://apify.com?fpr=ykgg9c) to open the actor.
2. Add one or more **numeric page IDs** to the `pageIds` input.
3. Set `maxReviews` per page.
4. Run the actor and download all reviews from the dataset.

**⭐ If this actor helps your workflow, please give it a star!**

***

### 📄 **Example Use Cases**

#### 💼 Reputation Management

Monitor customer reviews and ratings in real-time to manage your brand's online reputation effectively.

#### 📊 Sentiment Analysis

Analyze positive and negative feedback to understand customer satisfaction and identify areas for improvement.

#### 🔍 Competitive Intelligence

Collect reviews from competitor pages to benchmark performance and identify market opportunities.

#### � Dataset Building

Create labeled datasets of customer reviews for ML training, sentiment models, or NLP applications.

***

*Built with ❤️ using Apify Platform | Facebook Page Reviews Scraper v1.0*

***

**Disclaimer**: This actor is designed for extracting publicly available Facebook page reviews only. Users are responsible for complying with Facebook's Terms of Service and all applicable laws. Use this tool ethically and responsibly for legitimate purposes only. Do not use for spam, harassment, or any malicious activities.

# Actor input Schema

## `pageIds` (type: `array`):

Enter one or more numeric Facebook page IDs (e.g., '100064718047398'). Facebook page URLs are not allowed - only numeric IDs.

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

Set the maximum number of reviews to scrape from each page. This helps control the dataset size and actor runtime. Set to a higher value to get more reviews.

## Actor input object example

```json
{
  "pageIds": [
    "100064718047398",
    "100050652602097"
  ],
  "maxReviews": 5
}
```

# 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 = {
    "pageIds": [
        "100064718047398",
        "100050652602097"
    ],
    "maxReviews": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("igview-owner/facebook-page-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 = {
    "pageIds": [
        "100064718047398",
        "100050652602097",
    ],
    "maxReviews": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("igview-owner/facebook-page-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 '{
  "pageIds": [
    "100064718047398",
    "100050652602097"
  ],
  "maxReviews": 5
}' |
apify call igview-owner/facebook-page-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Page Reviews Scraper",
        "description": "Scrape Facebook page reviews in minutes. Extract ratings, review text, author details, reactions, tags and sentiment from public pages. Perfect for reputation monitoring, competitor analysis, and customer feedback reports.",
        "version": "1.0",
        "x-build-id": "5VBuNLKBgjdxh0Pan"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/igview-owner~facebook-page-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-igview-owner-facebook-page-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/igview-owner~facebook-page-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-igview-owner-facebook-page-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/igview-owner~facebook-page-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-igview-owner-facebook-page-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": [
                    "pageIds"
                ],
                "properties": {
                    "pageIds": {
                        "title": "📄 Facebook Page IDs",
                        "minItems": 1,
                        "maxItems": 10,
                        "type": "array",
                        "description": "Enter one or more numeric Facebook page IDs (e.g., '100064718047398'). Facebook page URLs are not allowed - only numeric IDs.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d+$"
                        },
                        "default": [
                            "100064718047398"
                        ]
                    },
                    "maxReviews": {
                        "title": "⭐ Maximum Reviews Per Page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Set the maximum number of reviews to scrape from each page. This helps control the dataset size and actor runtime. Set to a higher value to get more reviews.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
