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

Extract public Facebook Page metadata, follower/like text, contact fields, profile images, and visible public post links from Page URLs or handles.

- **URL**: https://apify.com/fetch\_cat/facebook-pages-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.07 / 1,000 facebook page or post records

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Facebook Pages Scraper

Extract public Facebook Page profile metadata and visible public post links from Facebook Page URLs or handles.

Facebook Pages Scraper helps social media, brand monitoring, lead generation, and competitive intelligence teams turn public Facebook Page information into a clean Apify dataset.

### What does Facebook Pages Scraper do?

Facebook Pages Scraper collects public information from Facebook Pages that are visible without logging in.

It can save:

- 📘 Page name and canonical Facebook URL
- 🆔 Page ID when visible
- 🔗 Page handle
- 📝 Public description/about text
- 👥 Like and engagement text when visible
- 🖼️ Profile image URL
- 🌐 Public website, phone, and email when visible
- 🧾 Recent public post links when Facebook exposes them in logged-out HTML
- ⏱️ Scrape timestamp for every record

The actor is designed for public Page monitoring, not private Facebook data.

### Who is it for?

#### Brand and social media teams

Track owned and competitor Facebook Pages in a repeatable spreadsheet-friendly format.

#### Lead generation teams

Collect public business Page metadata such as websites, emails, and phone numbers when those details are visible on the Page.

#### Competitive intelligence analysts

Export Page names, descriptions, image URLs, and engagement text for recurring market snapshots.

#### Agencies and consultants

Create simple client reports from lists of public Facebook Page URLs or handles.

### Why use this actor?

- ✅ Simple input: paste Page URLs or handles
- ✅ Public-data only: no Facebook login, cookies, or tokens
- ✅ Normalized output: stable field names for exports and integrations
- ✅ Batch friendly: process multiple Pages in one run
- ✅ Apify native: datasets, API, scheduling, webhooks, and integrations included

### What Facebook Pages can it scrape?

Use public Facebook Pages such as:

- `https://www.facebook.com/NASA`
- `https://www.facebook.com/Meta`
- `NASA`
- `Meta`

The actor skips pages that Facebook does not expose publicly to logged-out visitors.

### What data can you extract?

| Field | Description |
| --- | --- |
| `recordType` | `page` or `post` |
| `input` | Original URL or handle you entered |
| `url` | Canonical Facebook Page URL |
| `handle` | Facebook Page handle when parseable |
| `pageId` | Numeric Page/profile ID when visible |
| `name` | Page name |
| `title` | Full page title |
| `description` | Public description/about text |
| `category` | Page category when visible |
| `website` | Public external website when visible |
| `phone` | Public phone number when visible |
| `email` | Public email address when visible |
| `address` | Public address when visible |
| `likesText` | Likes text as shown publicly |
| `likesCount` | Parsed likes count when possible |
| `followersText` | Followers text when visible |
| `followersCount` | Parsed followers count when possible |
| `talkingAboutText` | Public talking-about text |
| `talkingAboutCount` | Parsed talking-about count |
| `profileImageUrl` | Public profile image URL |
| `coverImageUrl` | Public cover image URL when visible |
| `postUrl` | Public post URL for `post` records |
| `postId` | Post ID when parseable |
| `text` | Post text when visible |
| `timestampText` | Post timestamp text when visible |
| `timestampIso` | Parsed timestamp when available |
| `mediaUrls` | Visible media URLs |
| `reactionCount` | Visible reaction count |
| `commentCount` | Visible comment count |
| `shareCount` | Visible share count |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Facebook Pages?

This actor uses pay-per-event pricing.

You pay a small **$0.005 run-start fee** and then a per-record fee for each Facebook Page or visible post record saved to the dataset. The current BRONZE per-record price is **$0.00012252** (about **$0.12 per 1,000 records**), with lower prices on higher Apify usage tiers.

| Example run | Records saved | Estimated BRONZE cost |
| --- | ---: | ---: |
| Quick test | 10 records | ~$0.0062 |
| Small monitoring list | 100 records | ~$0.0173 |
| Larger export | 1,000 records | ~$0.1275 |

Free-plan users can run small tests affordably because the actor only charges for records it actually saves. Exact charges can vary slightly by Apify tier and the number of public Pages/posts Facebook exposes during the run.

### How to use Facebook Pages Scraper

1. Open the actor on Apify.
2. Add Facebook Page URLs in **Facebook Page URLs**.
3. Optionally add handles in **Facebook Page handles or URLs**.
4. Choose whether to include visible public post links.
5. Set the maximum posts per Page.
6. Click **Start**.
7. Download results from the dataset as JSON, CSV, Excel, XML, or RSS.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/NASA" },
    { "url": "https://www.facebook.com/Meta" }
  ],
  "pageUrls": ["NatGeo"],
  "includePosts": true,
  "maxPostsPerPage": 5,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Output example

```json
{
  "recordType": "page",
  "input": "https://www.facebook.com/NASA",
  "url": "https://www.facebook.com/NASA",
  "handle": "NASA",
  "pageId": "100044561550831",
  "name": "NASA - National Aeronautics and Space Administration",
  "description": "Explore the universe and discover our home planet. There's space for everybody. ✨",
  "likesText": "28,636,250 likes",
  "likesCount": 28636250,
  "talkingAboutText": "114,817 talking about this",
  "talkingAboutCount": 114817,
  "profileImageUrl": "https://...",
  "scrapedAt": "2026-06-22T00:00:00.000Z"
}
```

### Input settings

#### Facebook Page URLs

Use this field for full Facebook Page URLs. It supports Apify's request-list input editor.

#### Facebook Page handles or URLs

Use this field for a simple list of handles or URLs. A handle like `NASA` is converted to `https://www.facebook.com/NASA`.

#### Include visible public posts

When enabled, the actor saves public post link records if Facebook exposes them in the logged-out Page HTML.

#### Maximum posts per Page

Controls how many visible public post records can be saved per Page.

#### Proxy configuration

Most tests should start with no proxy or datacenter proxy. Use residential proxy only if your target region receives a Facebook login prompt or blocked response.

### Tips for best results

- Use Page URLs, not personal profiles.
- Keep first tests small: two or three Pages.
- Use public Pages that are visible in a browser without logging in.
- Set `maxPostsPerPage` to `0` if you only need Page profile records.
- Re-run on a schedule for recurring Page monitoring.

### Limits and caveats

Facebook changes public logged-out markup frequently.

Some fields may be `null` even when they appear to logged-in users. This happens when Facebook does not expose those fields to anonymous visitors.

This actor does not bypass logins, privacy settings, CAPTCHAs, or access controls.

### Integrations

Use Apify integrations to send Facebook Page data to:

- Google Sheets for social media reporting
- Slack for competitor monitoring alerts
- Make or Zapier for lead workflows
- Webhooks for internal data pipelines
- Apify datasets for scheduled exports

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/facebook-pages-scraper').call({
  pageUrls: ['NASA'],
  includePosts: true,
  maxPostsPerPage: 5
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/facebook-pages-scraper').call(run_input={
    'pageUrls': ['NASA'],
    'includePosts': True,
    'maxPostsPerPage': 5,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~facebook-pages-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"pageUrls":["NASA"],"includePosts":true,"maxPostsPerPage":5}'
```

### MCP server usage

You can use this actor through the Apify MCP server.

Claude Code or Claude Desktop tool URL:

```text
https://mcp.apify.com/?tools=fetch_cat/facebook-pages-scraper
```

Claude Code setup command:

```bash
claude mcp add apify-facebook-pages "https://mcp.apify.com/?tools=fetch_cat/facebook-pages-scraper"
```

Claude Desktop MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-facebook-pages": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/facebook-pages-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the public Facebook Page metadata for NASA and Meta."
- "Export Facebook Page profile images and descriptions for this competitor list."
- "Run Facebook Pages Scraper weekly and summarize changed descriptions."

### Scheduling

Use Apify schedules to monitor a list of Pages daily, weekly, or monthly.

A common workflow is:

1. Save a Page list in actor input.
2. Create a weekly schedule.
3. Send the dataset to Google Sheets or your data warehouse.
4. Compare changes over time.

### Data quality notes

The actor normalizes obvious numeric text such as likes and talking-about counts.

If Facebook returns abbreviated counts such as `1.2M`, the actor converts them to numbers where possible.

Raw display text is kept in separate fields so you can audit the original public wording.

### Legality

This actor is intended for public Facebook Page information that is visible without logging in.

You are responsible for using the data lawfully, respecting Facebook's terms, and complying with privacy, data protection, and intellectual property rules that apply to your use case.

Do not use this actor for private data, restricted data, account-only data, or data that you are not allowed to process.

### FAQ

#### Can I scrape private Facebook data?

No. This actor is for public Facebook Page data visible without logging in.

#### Do I need Facebook cookies or an access token?

No. The actor does not request credentials, cookies, app tokens, or user tokens.

### Troubleshooting

#### Why did a Page return no data?

The Page may be private, unavailable in your region, redirected to login, age-restricted, or temporarily blocked for logged-out visitors.

Try another public Page or enable Apify Proxy in the input.

#### Why are some fields empty?

Facebook often shows different data to logged-in users than it exposes publicly. Empty fields mean the data was not visible in the public logged-out response.

#### Why are there fewer post records than requested?

Post records are saved only when Facebook exposes public post links in logged-out HTML. Set `maxPostsPerPage` higher only after confirming posts are visible for your Pages.

### Related scrapers

Explore other actors by the same publisher:

- https://apify.com/fetch\_cat/google-search-results-scraper
- https://apify.com/fetch\_cat/google-maps-reviews-scraper
- https://apify.com/fetch\_cat/github-repositories-search-scraper

### Support

If a public Facebook Page does not work as expected, include the Page URL, your actor input, and the run ID when reporting the issue.

### Changelog

#### 0.1

Initial public Facebook Page profile scraper with optional visible public post link records.

# Actor input Schema

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

Public Facebook Page URLs to scrape, such as https://www.facebook.com/NASA.

## `pageUrls` (type: `array`):

Optional simple list of Facebook Page handles or URLs. Examples: NASA, Meta, https://www.facebook.com/NASA.

## `includePosts` (type: `boolean`):

When enabled, the actor also saves recent public post link records if Facebook exposes them in logged-out HTML.

## `maxPostsPerPage` (type: `integer`):

Maximum visible public post records to save per Page. Set to 0 for page profile records only.

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

Optional Apify Proxy settings. Datacenter proxy is recommended first; use residential only if your target pages are blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/NASA"
    },
    {
      "url": "https://www.facebook.com/Meta"
    }
  ],
  "pageUrls": [
    "NASA"
  ],
  "includePosts": true,
  "maxPostsPerPage": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/NASA"
        },
        {
            "url": "https://www.facebook.com/Meta"
        }
    ],
    "pageUrls": [
        "NASA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/facebook-pages-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        { "url": "https://www.facebook.com/NASA" },
        { "url": "https://www.facebook.com/Meta" },
    ],
    "pageUrls": ["NASA"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/facebook-pages-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/NASA"
    },
    {
      "url": "https://www.facebook.com/Meta"
    }
  ],
  "pageUrls": [
    "NASA"
  ]
}' |
apify call fetch_cat/facebook-pages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Pages Scraper",
        "description": "Extract public Facebook Page metadata, follower/like text, contact fields, profile images, and visible public post links from Page URLs or handles.",
        "version": "0.1",
        "x-build-id": "yAToVLPKuaev9utEV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~facebook-pages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-facebook-pages-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/fetch_cat~facebook-pages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-facebook-pages-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/fetch_cat~facebook-pages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-facebook-pages-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 to scrape, such as https://www.facebook.com/NASA.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "pageUrls": {
                        "title": "Facebook Page handles or URLs",
                        "type": "array",
                        "description": "Optional simple list of Facebook Page handles or URLs. Examples: NASA, Meta, https://www.facebook.com/NASA.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePosts": {
                        "title": "Include visible public posts",
                        "type": "boolean",
                        "description": "When enabled, the actor also saves recent public post link records if Facebook exposes them in logged-out HTML.",
                        "default": true
                    },
                    "maxPostsPerPage": {
                        "title": "Maximum posts per Page",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum visible public post records to save per Page. Set to 0 for page profile records only.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Datacenter proxy is recommended first; use residential only if your target pages are blocked.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
