# Facebook Pages Scraper (`vortex_data/facebook-pages`) Actor

Stop wasting your budget on slow, resource-heavy browser-based scrapers. This is the fastest, most cost-effective, and data-rich Facebook Pages scraper on Apify, designed for high-scale lead generation, reputation monitoring, and competitor research.

- **URL**: https://apify.com/vortex\_data/facebook-pages.md
- **Developed by:** [VortexData](https://apify.com/vortex_data) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 6 total users, 2 monthly users, 84.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Pages Scraper

Extract **public Facebook Page data** — page details, posts, photos, videos, reels, reviews, and events — from one or more pages in a single run. **No login, no cookies, no manual setup.**

You give the Actor a list of Facebook page URLs. It returns one rich record per page that mirrors the well-known competitor scraper field-for-field, plus a few useful extras.

---

### What does Facebook Pages Scraper do?

For every Facebook page you provide, the Actor returns a single dataset record that contains:

- 🏷️ **Page details** — title, page ID, handle, categories, intro, address, phone, email, website, hours, rating (% recommend + review count), follower / likes / following counts, profile photo, cover photo, page creation date, ad status, ad library id, linked Instagram, and more (≈40 fields).
- 📝 **Recent posts** — text, URL, publish timestamp, reactions / comments / shares counts, author, attached media.
- 🖼️ **Photos** — IDs and CDN URLs for the most recent uploads.
- 🎥 **Videos** — title-less videos with description, play count, publish time, permalink.
- 🎞️ **Reels** — short-form video URLs with timestamps.
- ⭐ **Reviews** — public recommendations (when the page has any).
- 📅 **Events** — upcoming and past events with names, URLs, and venues.

Each section is a nested array inside the main page record, so the dataset stays one row per URL — easy to filter, view, and export.

---

### Why use this Actor?

- **No credentials needed.** It works fully anonymously — you don't have to share Facebook cookies, log in, or maintain session pools.
- **One row per page.** Drop-in compatible with the popular community Facebook Pages Scraper, so you can replace it without rewriting downstream code.
- **All data types in a single run.** No need to launch the Actor 8 times to collect everything.
- **Fast.** A typical page returns in 6–12 seconds on Apify Datacenter US, even with full extraction.
- **Apify-native.** Works with the standard `startUrls` input format, dataset views, schedules, integrations, and REST API.

#### Common use cases

- Lead enrichment — pull contacts and rating signals for local-business pages.
- Reputation monitoring — track review counts and overall rating over time.
- Social-media tracking — collect recent posts, videos, and reels across competitor pages.
- Event monitoring — list upcoming and past events for venues, restaurants, or brands.

---

### How to use it

1. Open the Actor on Apify and switch to the **Input** tab.
2. Paste one or more Facebook page URLs into **Start URLs** (each entry is a `{"url": "https://www.facebook.com/<handle>/"}` object). You can also use the **Page handles or IDs** field with bare handles like `copperkettleyqr` or numeric page IDs — both formats are merged.
3. Pick **Max items per page section** (default 50) — it caps how many posts / photos / videos are kept per section. The page details object itself is always one per URL.
4. (Optional) Toggle **Parse all results** to walk every section to the end. This is much slower and more expensive — use only when you really need the entire archive.
5. Click **Save & Start**.

The Actor uses Apify Datacenter US Proxy internally — no configuration needed, no settings to tweak.

When the run finishes, open **Storage → Dataset** to view, filter, or export the results as JSON / CSV / Excel / XML / HTML.

---

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `startUrls` | `array<{url}>` | yes¹ | List of full Facebook page URLs. Each entry is `{"url": "https://www.facebook.com/<handle>/"}`. |
| `urls` | `array<string>` | yes¹ | Alternative input — accepts handles (`copperkettleyqr`) or numeric IDs (`100064027242849`). |
| `maxResults` | `integer` | no | How many items per section to keep (default `50`, max `10000`). |
| `parseAllResults` | `boolean` | no | Paginate every section to the end (default `false`). |

¹ At least one of `startUrls` or `urls` must contain a value.

#### Example — minimal input

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/copperkettleyqr/" }
  ]
}
````

#### Example — multiple pages with a tighter cap

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/copperkettleyqr/" },
    { "url": "https://www.facebook.com/Microsoft/" }
  ],
  "urls": [
    "100064027242849"
  ],
  "maxResults": 20
}
```

***

### Output

One record per input URL is pushed to the default Apify dataset. Top-level keys are the page-level fields; per-section content lives in nested arrays.

#### Sample (truncated)

```json
{
  "type": "page",
  "facebookUrl": "https://www.facebook.com/copperkettleyqr/",
  "pageUrl": "https://www.facebook.com/copperkettleyqr/",
  "pageId": "100064027242849",
  "facebookId": "100064027242849",
  "pageName": "copperkettleyqr",
  "displayName": "The Copper Kettle Restaurant",
  "title": "The Copper Kettle Restaurant | Regina SK",
  "intro": "Longstanding local restaurant. Mediterranean specialties...",
  "info": [
    "The Copper Kettle Restaurant, Regina. 3,212 likes",
    "39 talking about this",
    "1,136 were here. Longstanding local restaurant..."
  ],
  "categories": ["Page", "Pizza place"],
  "category": "Pizza place",
  "likes": 3212,
  "followers": 3212,
  "followings": 341,
  "talking_about": 39,
  "were_here": 1136,
  "rating": "94% recommend (202 Reviews)",
  "ratings": "94% recommend (202 Reviews)",
  "ratingOverall": 94,
  "ratingCount": 202,
  "phone": "+1 306-525-3545",
  "email": "copperkettle.events@gmail.com",
  "website": "http://www.thecopperkettle.online/",
  "websites": [
    "https://www.bing.com/maps/...",
    "https://www.instagram.com/copperkettleyqr",
    "http://www.thecopperkettle.online/"
  ],
  "alternativeSocialMedia": "https://www.instagram.com/copperkettleyqr",
  "instagram": [
    {"username": "copperkettleyqr", "url": "https://www.instagram.com/copperkettleyqr"}
  ],
  "address": "1953 Scarth Street, Regina, SK, Canada, S4P 2H1",
  "addressUrl": "https://www.bing.com/maps/...",
  "services": "Outdoor seating",
  "business_services": "Outdoor seating",
  "priceRange": "$$",
  "business_price": "Price Range · $$",
  "business_hours": "Open now",
  "creation_date": "October 29, 2014",
  "ad_status": "This Page is currently running ads.",
  "pageAdLibrary": {"id": "851606664870954", "pamv_comms_data": null},
  "profilePictureUrl": "https://lookaside.fbsbx.com/lookaside/crawler/media/?media_id=100064027242849",
  "profilePhoto": "https://www.facebook.com/photo/?fbid=...&set=a....",
  "coverPhotoUrl": "https://lookaside.fbsbx.com/lookaside/crawler/media/?media_id=...",
  "verified": false,

  "posts": [
    {
      "type": "post",
      "post_id": "1259602942850602",
      "url": "https://www.facebook.com/copperkettleyqr/posts/...",
      "message": "THE SASKATCHEWAN ROUGHRIDERS WIN THE 112TH GREY CUP! 🏆",
      "timestamp": 1763349499,
      "reactions_count": 10,
      "comments_count": 0,
      "reshare_count": 1,
      "author": {"id": "100064027242849", "name": "...", "url": "..."},
      "media": ["https://lookaside.fbsbx.com/..."]
    }
  ],

  "photos":     [ /* … */ ],
  "videos":     [ /* … */ ],
  "reels":      [ /* … */ ],
  "past_events":[ /* … */ ],

  "scraped_at": "2026-05-09T08:12:34.567+00:00"
}
```

If a section has zero records (e.g. the page has no public reviews), that key is **omitted from the record entirely** — keeping the JSON tight.

***

### Pricing and runtime

The Actor is billed per Apify compute unit + Apify Proxy traffic — there are no per-result fees declared by the Actor itself. Internally the Actor uses Apify Datacenter US Proxy, the cheapest pool, which gives sub-second per-request latency for Facebook.

Typical runtime per URL:

| Workload | Wall-clock |
| --- | --- |
| 1 page, default `maxResults=50` | ~6–12 seconds |
| 100 pages, default | ~10–20 minutes (sequential per page, 8 sections concurrent within each) |
| `parseAllResults=true` on a busy page | minutes per page (depends on FB's pagination depth) |

Each request rotates through a fresh exit IP, so you don't have to pre-provision sticky sessions.

***

### How it works (under the hood)

1. **Resolve every input URL / handle / numeric id** to a canonical Facebook page URL.
2. For each page, fetch up to **three Facebook endpoints concurrently**: `/about/` (page metadata), `/about_profile_transparency/` (page creation date, ad status), and the page root `/` (profile photo viewer URL).
3. For listing sections (posts, photos, videos, reels, reviews, future events, past events) fetch each section URL in parallel.
4. Parse the embedded GraphQL JSON inside the HTML, extract structured records, and merge per-page results into one aggregate record.
5. Strip empty arrays and `null` fields, then push exactly one polished record per URL to the dataset.

The Actor uses `curl_cffi` with **Chrome TLS impersonation** and the `facebookexternalhit/1.1` user-agent — the same combination Facebook uses internally for link-preview crawling — which lets it pull rich page data without any authentication.

***

### Tips and best practices

- **Keep `maxResults` small** (the default 50 is usually enough) when first testing the Actor on new pages.
- **Avoid `parseAllResults=true`** unless you really need every post — busy pages with thousands of items will run for many minutes per page.
- **Run on a schedule** for monitoring: the Apify Console lets you trigger this Actor every X hours and pipe new dataset items into webhooks, integrations, or your own infrastructure.

***

### FAQ

**Does this Actor scrape personal Facebook profiles or Groups?**
No. It is for public **Pages** only. URLs that match `/groups/` or personal `profile.php` profiles are rejected at validation.

**Why are some fields like `past_events[*].timestamp` `null`?**
Facebook's anonymous bundle does not ship every field for every record. We fill what FB serves; missing fields are omitted entirely from the output to keep records clean. To collect the missing fields you would need an authenticated session — out of scope for this Actor.

**Can I provide just a page handle without the full URL?**
Yes. Use the **Page handles or IDs** input field for bare handles (`copperkettleyqr`) or numeric IDs (`100064027242849`).

**The locale of the output isn't English.**
Facebook localises page output by the geo of the exit IP. The Actor pins the internal proxy to a United States exit so you always receive native en-US output (`Reviews` capitalised, `$$` price symbols, `mkt=en-US` in map links).

**Is this legal?**
You are responsible for using this Actor in compliance with applicable laws, Facebook's terms, and the rules of your specific use case. Only collect and use data you are allowed to process.

***

### Run programmatically

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("your-username/facebook-pages").call(run_input={
    "startUrls": [{"url": "https://www.facebook.com/copperkettleyqr/"}],
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('your-username/facebook-pages').call({
  startUrls: [{ url: 'https://www.facebook.com/copperkettleyqr/' }],
  maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(console.log);
```

#### CLI

```bash
echo '{"startUrls":[{"url":"https://www.facebook.com/copperkettleyqr/"}]}' \
  | apify call your-username/facebook-pages --silent --output-dataset
```

***

### Support

Open an Issue on the Actor's Apify page if you spot a bug, want a new field added, or have a custom-version request.

# Actor input Schema

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

Paste the full URL of each Facebook page you want to scrape (one per line). Example: https://www.facebook.com/copperkettleyqr/. Only public Pages are supported — personal profiles and Groups are not.

## `urls` (type: `array`):

Use this if you have just the handle (the part after facebook.com/, e.g. 'copperkettleyqr') or a numeric page ID (e.g. '100064027242849'). These are merged with the URLs above — you don't have to fill in both fields.

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

How many posts / photos / videos / reels / events to keep per page. Page details (name, address, rating, etc.) are always returned in full. Ignored when 'Scrape every available item' is on.

## `parseAllResults` (type: `boolean`):

Turn on to keep loading older posts, photos, etc. until Facebook runs out of items. Off by default — leave off unless you really need the entire archive, because busy pages can take many minutes.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/copperkettleyqr/"
    }
  ],
  "maxResults": 50,
  "parseAllResults": false
}
```

# Actor output Schema

## `pages` (type: `string`):

The main dataset — one row per Facebook page from your input. Each row carries the full page details at the top, plus nested arrays of posts, photos, videos, reels, reviews, and events.

## `runSummary` (type: `string`):

A small JSON object with the totals — how many pages you asked for, how many were scraped, which sections (if any) had problems, and the time the run finished.

# 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/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vortex_data/facebook-pages").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/" }] }

# Run the Actor and wait for it to finish
run = client.actor("vortex_data/facebook-pages").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/"
    }
  ]
}' |
apify call vortex_data/facebook-pages --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Pages Scraper",
        "description": "Stop wasting your budget on slow, resource-heavy browser-based scrapers. This is the fastest, most cost-effective, and data-rich Facebook Pages scraper on Apify, designed for high-scale lead generation, reputation monitoring, and competitor research.",
        "version": "0.1",
        "x-build-id": "Thczwmc146nHvJOXV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vortex_data~facebook-pages/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vortex_data-facebook-pages",
                "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/vortex_data~facebook-pages/runs": {
            "post": {
                "operationId": "runs-sync-vortex_data-facebook-pages",
                "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/vortex_data~facebook-pages/run-sync": {
            "post": {
                "operationId": "run-sync-vortex_data-facebook-pages",
                "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": "Paste the full URL of each Facebook page you want to scrape (one per line). Example: https://www.facebook.com/copperkettleyqr/. Only public Pages are supported — personal profiles and Groups are not.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "urls": {
                        "title": "Page handles or numeric IDs (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Use this if you have just the handle (the part after facebook.com/, e.g. 'copperkettleyqr') or a numeric page ID (e.g. '100064027242849'). These are merged with the URLs above — you don't have to fill in both fields.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxResults": {
                        "title": "Max items per section",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many posts / photos / videos / reels / events to keep per page. Page details (name, address, rating, etc.) are always returned in full. Ignored when 'Scrape every available item' is on.",
                        "default": 50
                    },
                    "parseAllResults": {
                        "title": "Scrape every available item (slower)",
                        "type": "boolean",
                        "description": "Turn on to keep loading older posts, photos, etc. until Facebook runs out of items. Off by default — leave off unless you really need the entire archive, because busy pages can take many minutes.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```