# Facebook Reviews Scraper - Ratings, Sentiment, No Login (`apivault_labs/facebook-reviews-scraper`) Actor

Scrape public Facebook page reviews & recommendations without login. Get reviewer, rating, text, date, photos + page rating summary, AI sentiment, contact email/phone, address & GPS. Keyword search, incremental only-new, dedup, date filter. Pay per result, hard cost caps - no runaway bills.

- **URL**: https://apify.com/apivault\_labs/facebook-reviews-scraper.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 review scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Facebook Reviews Scraper — Ratings, Sentiment & Contacts, No Login

![Facebook Reviews Scraper — ratings, recommendations, AI sentiment, contacts, no login](https://api.apify.com/v2/key-value-stores/E76hLVOROveornuAY/records/facebook-reviews-hero.jpg)

**Scrape public Facebook page reviews and recommendations without login or cookies.** Give it a page URL — or a business keyword — and get the **average rating, recommend %, individual reviews (reviewer, text, date, photos, likes)**, plus **AI sentiment analysis**, the page's **contact email/phone, website, address and GPS coordinates**. Export to JSON, CSV or Excel.

Built for reliability and predictable cost: hard spend caps, charge-only-on-delivery, datacenter-first proxy with residential fallback, retries — **no runaway bills**.

---

### ✅ What this Facebook review scraper does

- ⭐ **Rating summary** per page — average stars, rating count, recommend %, category
- 💬 **Individual reviews** — reviewer, recommends/rating, text, date, likes, comments, photos
- 🤖 **AI sentiment** — positive / negative / neutral + score per review and a run-level breakdown (token-free, no API key)
- 📇 **Page contacts** — email, phone, website, address + **GPS latitude/longitude** (turn reviews into leads)
- 🔁 **Incremental "only new reviews"** — perfect for monitoring; each run returns just the new ones
- 🧹 **Dedup, date filter, keyword filter, per-page & global caps**
- 🔎 **Keyword search** — discover public pages by business/brand name

No login, no cookies, no API key. Only public content.

### 📦 Output

**Per page (summary):** `pageName`, `pageUrl`, `pageId`, `category`, `avgRating`, `ratingCount`, `recommendPercent`, `recommendCount`, `emails`, `phones`, `websites`, `address`, `latitude`, `longitude`.

**Per review:** `reviewId`, `reviewerName`, `recommends`, `rating`, `text`, `reviewDate`, `likeCount`, `commentCount`, `photos`, `sentiment`, `sentimentScore`.

Plus a run-level `_summary` with the sentiment breakdown and positive %.

### ⚙️ Input

| Field | What it does |
|---|---|
| `startUrls` | Facebook page URLs (vanity, profile.php or bare ID) |
| `searchQueries` | Business/brand keywords to discover pages |
| `maxReviewsPerPage`, `maxResults`, `maxCostUsd` | Caps — the run stops at your limit |
| `sinceDays`, `keywordFilter` | Recency / text filters |
| `onlyNewSinceLastRun` | Incremental — only reviews not seen before |
| `analyzeSentiment` | AI sentiment per review (default on) |
| `enrichPageContacts` | Email / phone / website / address / GPS |
| `proxyCountry`, `maxConcurrency`, `timeout`, `maxRetries` | Geo + throughput + reliability |
| `notifyWebhookUrl` | POST each review to Zapier / Make / n8n in real time |

#### Example input

```json
{
  "startUrls": ["https://www.facebook.com/cocacola"],
  "searchQueries": ["pizza new york"],
  "maxReviewsPerPage": 100,
  "analyzeSentiment": true,
  "enrichPageContacts": true,
  "proxyCountry": "US"
}
````

### 🆚 Why choose this scraper

| Feature | This scraper | Typical competitor |
|---|:--:|:--:|
| Rating + reviews + engagement | ✅ | ✅ |
| **AI sentiment analysis** | ✅ | rare |
| **Contact email / phone (lead data)** | ✅ | rare |
| **GPS coordinates** | ✅ | rare |
| **Incremental only-new** | ✅ | rare |
| **Dedup by review id** | ✅ | rare |
| Category / taxonomy, retries, stealth, no-login | ✅ | rare |
| Hard spend cap (no runaway bills) | ✅ | rare |

### 💡 Use cases

- **Reputation monitoring** — track new reviews and sentiment over time (incremental mode)
- **Lead generation** — pull business contact + location from reviewed pages
- **Competitor analysis** — compare ratings, recommend %, sentiment across pages
- **Local SEO & market research** — ratings + GPS for map-based datasets
- Feed **n8n / Make / Zapier** and AI agents

### 💸 Pricing

Pay per result: a small `page` fee per page summary delivered, plus `review` per review saved. You're billed only for delivered data — duplicates, filtered and failed items are free. Use `maxResults` / `maxCostUsd` to cap spend.

### ❓ FAQ

**Do I need to log in?** No — only public reviews/recommendations are read.

**Will I get every review?** Logged-out Facebook exposes the rating summary plus a window of recent public recommendations. The summary (rating, recommend %, contacts, GPS) is always returned.

**How does incremental mode work?** With `onlyNewSinceLastRun`, the Actor remembers review IDs it already returned and skips them next run — only brand-new reviews come through.

**How do I avoid surprise costs?** Use `maxResults` and `maxCostUsd`; the run stops at your cap and only bills delivered results.

***

*Not affiliated with or endorsed by Facebook/Meta. Scrape only public data and use responsibly, in line with applicable laws and platform terms.*

# Actor input Schema

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

Public Facebook page URLs (or /<page>/reviews/). Supports /pagename/, /profile.php?id=..., and bare numeric page IDs. Each page's reviews/recommendations are scraped.

## `searchQueries` (type: `array`):

Optional. Business/brand keywords to discover public Facebook pages (via search engines) and scrape their reviews. Use instead of, or together with, URLs.

## `maxReviewsPerPage` (type: `integer`):

Cap on reviews/recommendations saved per page. Logged-out pages expose a window of recent public recommendations.

## `maxResults` (type: `integer`):

Hard cap on total reviews scraped and billed across all pages. Protects against runaway cost. 0 = no cap.

## `maxCostUsd` (type: `number`):

Hard budget in USD. The run stops once this estimated cost is reached. 0 = no budget cap.

## `sinceDays` (type: `integer`):

Recency filter — keep only reviews published within the last N days. Empty = no date filter.

## `keywordFilter` (type: `string`):

Optional. Keep only reviews whose text contains this keyword (case-insensitive).

## `onlyNewSinceLastRun` (type: `boolean`):

Skip reviews already returned in previous runs (state stored in a named key-value store). Great for monitoring — only brand-new reviews each run (gap feature, only 1/12).

## `analyzeSentiment` (type: `boolean`):

Classify each review as positive / negative / neutral with a score, and extract overall sentiment breakdown + top themes. Token-free (no LLM key needed).

## `enrichPageContacts` (type: `boolean`):

Pull the page's public contact email, phone, website and address + GPS coordinates into the page summary — turns reviews into lead data (gap feature, only 1/12).

## `includeMedia` (type: `boolean`):

Include photo/image URLs attached to reviews when present.

## `maxConcurrency` (type: `integer`):

How many pages to scrape in parallel. Recommended 3-8.

## `timeout` (type: `integer`):

Maximum time to wait for each page fetch.

## `maxRetries` (type: `integer`):

Retries for a blocked/failed fetch, each rotating a fresh proxy IP with backoff. 0-8.

## `useResidentialProxy` (type: `boolean`):

Datacenter proxy is used first (cheap). When a page is blocked on datacenter, the Actor escalates to Apify residential proxy. Disable to stay datacenter-only.

## `proxyCountry` (type: `string`):

ISO 2-letter country code (e.g. US, GB, DE). Geo-targets both proxies to get region-specific availability and avoid locale redirects. Empty = automatic.

## `dedupe` (type: `boolean`):

Drop duplicate input pages and duplicate reviews (same review ID), so the same review is never saved or billed twice.

## `notifyWebhookUrl` (type: `string`):

Optional. Each scraped review is POSTed as JSON to this URL the moment it's found (Zapier / Make / n8n / Slack).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/NASA",
    "https://www.facebook.com/cocacola"
  ],
  "searchQueries": [],
  "maxReviewsPerPage": 50,
  "maxResults": 500,
  "maxCostUsd": 0,
  "onlyNewSinceLastRun": false,
  "analyzeSentiment": true,
  "enrichPageContacts": true,
  "includeMedia": true,
  "maxConcurrency": 5,
  "timeout": 45,
  "maxRetries": 2,
  "useResidentialProxy": true,
  "proxyCountry": "US",
  "dedupe": true
}
```

# 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": [
        "https://www.facebook.com/NASA",
        "https://www.facebook.com/cocacola"
    ],
    "searchQueries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/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": [
        "https://www.facebook.com/NASA",
        "https://www.facebook.com/cocacola",
    ],
    "searchQueries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/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": [
    "https://www.facebook.com/NASA",
    "https://www.facebook.com/cocacola"
  ],
  "searchQueries": []
}' |
apify call apivault_labs/facebook-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reviews Scraper - Ratings, Sentiment, No Login",
        "description": "Scrape public Facebook page reviews & recommendations without login. Get reviewer, rating, text, date, photos + page rating summary, AI sentiment, contact email/phone, address & GPS. Keyword search, incremental only-new, dedup, date filter. Pay per result, hard cost caps - no runaway bills.",
        "version": "0.1",
        "x-build-id": "o4weHAePbj79yV1oL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apivault_labs~facebook-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apivault_labs-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/apivault_labs~facebook-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apivault_labs-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/apivault_labs~facebook-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apivault_labs-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",
                "properties": {
                    "startUrls": {
                        "title": "Facebook Page URLs",
                        "type": "array",
                        "description": "Public Facebook page URLs (or /<page>/reviews/). Supports /pagename/, /profile.php?id=..., and bare numeric page IDs. Each page's reviews/recommendations are scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Keyword search (optional)",
                        "type": "array",
                        "description": "Optional. Business/brand keywords to discover public Facebook pages (via search engines) and scrape their reviews. Use instead of, or together with, URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerPage": {
                        "title": "Max reviews per page",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on reviews/recommendations saved per page. Logged-out pages expose a window of recent public recommendations.",
                        "default": 50
                    },
                    "maxResults": {
                        "title": "Max results (cost cap)",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on total reviews scraped and billed across all pages. Protects against runaway cost. 0 = no cap.",
                        "default": 500
                    },
                    "maxCostUsd": {
                        "title": "Max cost USD (cost cap)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Hard budget in USD. The run stops once this estimated cost is reached. 0 = no budget cap.",
                        "default": 0
                    },
                    "sinceDays": {
                        "title": "Only reviews from last N days",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Recency filter — keep only reviews published within the last N days. Empty = no date filter."
                    },
                    "keywordFilter": {
                        "title": "Review text keyword filter",
                        "type": "string",
                        "description": "Optional. Keep only reviews whose text contains this keyword (case-insensitive)."
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Incremental — only new reviews",
                        "type": "boolean",
                        "description": "Skip reviews already returned in previous runs (state stored in a named key-value store). Great for monitoring — only brand-new reviews each run (gap feature, only 1/12).",
                        "default": false
                    },
                    "analyzeSentiment": {
                        "title": "AI sentiment analysis",
                        "type": "boolean",
                        "description": "Classify each review as positive / negative / neutral with a score, and extract overall sentiment breakdown + top themes. Token-free (no LLM key needed).",
                        "default": true
                    },
                    "enrichPageContacts": {
                        "title": "Extract page contact (email / phone)",
                        "type": "boolean",
                        "description": "Pull the page's public contact email, phone, website and address + GPS coordinates into the page summary — turns reviews into lead data (gap feature, only 1/12).",
                        "default": true
                    },
                    "includeMedia": {
                        "title": "Include review photos",
                        "type": "boolean",
                        "description": "Include photo/image URLs attached to reviews when present.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many pages to scrape in parallel. Recommended 3-8.",
                        "default": 5
                    },
                    "timeout": {
                        "title": "Timeout per page (seconds)",
                        "minimum": 15,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time to wait for each page fetch.",
                        "default": 45
                    },
                    "maxRetries": {
                        "title": "Max retries per page",
                        "minimum": 0,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Retries for a blocked/failed fetch, each rotating a fresh proxy IP with backoff. 0-8.",
                        "default": 2
                    },
                    "useResidentialProxy": {
                        "title": "Allow residential proxy fallback (recommended)",
                        "type": "boolean",
                        "description": "Datacenter proxy is used first (cheap). When a page is blocked on datacenter, the Actor escalates to Apify residential proxy. Disable to stay datacenter-only.",
                        "default": true
                    },
                    "proxyCountry": {
                        "title": "Proxy country code (geo-targeting)",
                        "type": "string",
                        "description": "ISO 2-letter country code (e.g. US, GB, DE). Geo-targets both proxies to get region-specific availability and avoid locale redirects. Empty = automatic.",
                        "default": "US"
                    },
                    "dedupe": {
                        "title": "Deduplicate",
                        "type": "boolean",
                        "description": "Drop duplicate input pages and duplicate reviews (same review ID), so the same review is never saved or billed twice.",
                        "default": true
                    },
                    "notifyWebhookUrl": {
                        "title": "Real-time webhook URL",
                        "type": "string",
                        "description": "Optional. Each scraped review is POSTed as JSON to this URL the moment it's found (Zapier / Make / n8n / Slack)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
