# Facebook Posts Scraper (`scrapesmith/facebook-posts-scraper`) Actor

🔥$0.7/1000 results🔥 Scrape posts from any public Facebook page or profile. Extract post text, reactions, comments count, shares, timestamps, and author details. 350+ posts/min. Scrape 10 years history. Export as JSON, CSV, Excel. API, MCP, and webhook ready for Claude, ChatGPT, and AI agents.

- **URL**: https://apify.com/scrapesmith/facebook-posts-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 7 total users, 5 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Posts Scraper

The fastest Facebook posts scraper on Apify. Extract posts from any public Facebook page or profile — post text, reactions, comments, shares, author details, and timestamps. **350+ posts per minute**.

### 🔍 What does Facebook Posts Scraper do?

This scraper collects all publicly visible posts from any Facebook page or personal profile. Paste one or more page URLs and get structured, export-ready data — JSON, CSV, or Excel.

Use it for 📊 **social media analytics**, 🕵️ **competitor monitoring**, 📈 **content performance tracking**, 🧠 **sentiment analysis**, 📝 **content calendar research**, 🎯 **audience insights**, 👂 **social listening**, and 📚 **academic research**.

### 📦 What data can you extract?

For every post, the scraper returns:

| Field | Description |
|-------|-------------|
| `postText` | 📝 Full post text / caption |
| `postUrl` | 🔗 Direct permalink to the post |
| `postId` | 🆔 Unique Facebook post ID |
| `timestamp` | 🕐 Unix timestamp (milliseconds) when published |
| `reactionsCount` | ❤️ Total reactions (like, love, wow, haha, sad, angry) |
| `commentsCount` | 💬 Number of comments on the post |
| `sharesCount` | 🔄 Number of times the post was shared |
| `authorName` | 👤 Page or profile name that published the post |
| `authorId` | 🆔 Facebook user/page ID of the author |
| `authorProfilePic` | 🖼️ Author's profile picture URL |
| `pageUrl` | 🌐 URL of the page being scraped |

### 🚀 How to scrape Facebook page posts

1. 🔗 **Go to any Facebook page** (brand, news, celebrity, public figure)
2. 📋 **Copy the page URL** from your browser
3. 📝 **Paste the URL(s)** into the scraper input
4. 🔢 **Set the limit** — how many posts and how far back in time
5. ▶️ **Run the scraper** and download your data in seconds

#### 🌐 Supported URL formats

- 📄 Pages: `https://www.facebook.com/PageName`
- 👤 Profiles: `https://www.facebook.com/profile.php?id=123456789`
- 🏢 Business pages: `https://www.facebook.com/business-name`
- 📰 News pages: `https://www.facebook.com/cnn`

### ⚙️ Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `pageUrls` | Array of strings | 🔗 List of Facebook page or profile URLs to scrape |
| `maxPostsPerPage` | Integer | 🔢 Maximum posts per page (default: 500, max: 10,000) |
| `daysBack` | Integer | 📅 How far back to scrape (default: 365 days, max: 3,650 = 10 years) |

### 📥 Example input

```json
{
    "pageUrls": [
        "https://www.facebook.com/Meta",
        "https://www.facebook.com/cnn"
    ],
    "maxPostsPerPage": 1000,
    "daysBack": 365
}
````

### 📤 Example output

```json
{
    "pageUrl": "https://www.facebook.com/Meta",
    "postId": "1075637535125456",
    "postUrl": "https://www.facebook.com/Meta/posts/1075637535125456",
    "postText": "Exciting updates coming to our platform! Here's what's new this week 🚀",
    "timestamp": 1783701511000,
    "reactionsCount": 12500,
    "commentsCount": 843,
    "sharesCount": 1205,
    "authorName": "Meta",
    "authorId": "100080376596424",
    "authorProfilePic": "https://scontent.xx.fbcdn.net/v/..."
}
```

### 💰 How much does it cost to scrape Facebook posts?

The scraper uses Apify's pay-per-result pricing. You only pay for the posts you actually get — zero waste.

- 🆓 **Free tier**: 10 posts per run — test before you buy, no credit card needed
- ⚡ **Speed**: 350+ posts per minute on high-volume pages
- 🪶 **Memory**: Runs on just 256 MB — minimal compute cost
- 📅 **Depth**: Scrape up to 10 years of post history in a single run

Check the **Pricing** tab above for current per-result rates.

### 🏆 Why choose this Facebook Posts Scraper?

#### ⚡ Fastest on the platform

Proprietary speed engine delivers **350+ posts/min on active pages** and **200+ posts/min even on slow pages**. Automatically optimizes for each page's activity level.

#### 📅 Full history extraction

Scrape up to **10 years** of post history. No slowdown at depth — post #5,000 loads just as fast as post #1.

#### 🔄 Multi-page batch scraping

Pass multiple page URLs in a single run. Pages are processed back-to-back with zero downtime between them.

#### 🛡️ Enterprise reliability

Built-in health monitoring with automatic failover. If something goes wrong mid-run, the scraper self-heals and continues — no false stops, no missed data.

### 💡 Use cases

#### 📊 Social media analytics & reporting

Track posting frequency, engagement rates, and content performance over time. Export months of posts to build dashboards in Google Data Studio, Tableau, or Power BI.

#### 🕵️ Competitor monitoring

Monitor what competitors post, how often, and what gets the most engagement. Identify their top-performing content themes and posting schedules.

#### 📈 Content strategy & calendar planning

Analyze a page's historical posting patterns — what type of content drives reactions, comments, and shares. Use the data to plan your own content calendar.

#### 🧠 Sentiment analysis & NLP

Feed structured post data (text + engagement metrics + timestamps) into your NLP pipeline. Track how sentiment evolves across thousands of posts over months or years.

#### 📰 Media monitoring & PR

Track news organizations, government pages, and public figures. Get alerts when specific pages post about your brand or industry.

#### 👂 Social listening at scale

Monitor dozens of Facebook pages simultaneously. Schedule recurring runs to build a time-series dataset of public Facebook activity.

#### 🎓 Academic & market research

Collect public post data for research. Export as CSV for analysis in Python, R, SPSS, or Excel. Timestamp precision enables time-series analysis.

#### 🎯 Lead generation & audience research

Identify brands, influencers, and organizations in your niche. Analyze their post engagement to find the most active audiences and communities.

### 🔌 Integrations

Connect Facebook Posts Scraper to your workflow:

- 📊 **Google Sheets** — auto-export posts to a spreadsheet
- 💬 **Slack / Discord** — get notified when scraping completes
- ⚡ **Zapier / Make** — trigger downstream workflows
- 🪝 **Webhooks** — POST results to your own API endpoint
- ☁️ **Amazon S3 / Google Cloud** — store datasets in cloud storage

Use the [Apify API](https://docs.apify.com/api) or any of the official [Apify client libraries](https://docs.apify.com/api/client/js) (JavaScript, Python) to integrate programmatically.

### 🤖 MCP server integration (AI agents & LLMs)

This actor works as a **tool for AI agents** via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Connect it to **Claude**, **ChatGPT**, **Cursor**, **Windsurf**, or any MCP-compatible AI assistant to let your agent scrape Facebook posts autonomously.

#### 🟣 Use with Claude Desktop / Claude Code

Add the Apify MCP server to your Claude config:

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": ["-y", "@anthropic-ai/apify-mcp-server"],
            "env": {
                "APIFY_API_TOKEN": "YOUR_APIFY_TOKEN"
            }
        }
    }
}
```

Then ask Claude: *"Scrape the last 500 posts from facebook.com/cnn and summarize the top themes"*

#### 🟢 Use with OpenAI / GPT agents

Apify actors are available as OpenAI tools via the Apify platform. See [Apify + OpenAI integration docs](https://docs.apify.com/platform/integrations/openai).

#### 🦜 Use with LangChain / LlamaIndex

```python
from langchain_community.utilities import ApifyWrapper

apify = ApifyWrapper()
loader = apify.call_actor(
    actor_id="YOUR_ACTOR_ID",
    run_input={
        "pageUrls": ["https://www.facebook.com/cnn"],
        "maxPostsPerPage": 500,
    },
    dataset_mapping_function=lambda item: f"{item['postText']} (Reactions: {item['reactionsCount']})",
)
```

#### 🧩 Why use this with AI agents?

- 🔬 **Research automation**: Agent scrapes years of page history → analyzes trends → generates report
- 📚 **RAG pipelines**: Feed real-time Facebook post data into retrieval-augmented generation
- 📊 **Analytics workflows**: Agent collects posts → computes engagement metrics → builds dashboard
- 🕵️ **Competitive intel**: Agent monitors competitor pages daily and summarizes posting patterns
- 🎯 **Content ideation**: Agent analyzes top-performing posts across competitors → suggests content ideas

### 🔧 API access

Call the scraper programmatically using the Apify API:

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("YOUR_ACTOR_ID").call(run_input={
    "pageUrls": ["https://www.facebook.com/Meta"],
    "maxPostsPerPage": 500,
    "daysBack": 365,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['authorName']}: {item['postText'][:80]}... ({item['reactionsCount']} reactions)")
```

#### JavaScript / TypeScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('YOUR_ACTOR_ID').call({
    pageUrls: ['https://www.facebook.com/Meta'],
    maxPostsPerPage: 500,
    daysBack: 365,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.authorName}: ${item.postText?.slice(0, 80)}`));
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -X POST -H "Content-Type: application/json" \
  -d '{"pageUrls":["https://www.facebook.com/Meta"],"maxPostsPerPage":500}'
```

### ❓ FAQ

#### 🔐 Does this scraper need my Facebook login?

No. The scraper works without your Facebook credentials. It accesses only publicly available data.

#### 🔢 How many posts can I scrape?

Up to **10,000 posts per page** and up to **10 years** of history. Most pages have between 500–5,000 posts.

#### ⚡ How fast is it?

**350+ posts per minute** on high-volume pages (news, media, brands). Smaller pages that post less frequently run at 150–250 posts per minute.

#### 📄 Can I scrape multiple pages in one run?

Yes. Pass as many page URLs as you need. They're processed sequentially with full speed optimization per page.

#### 🔒 Can I scrape private profiles or groups?

No. Only publicly visible page and profile posts are accessible.

#### 📱 What types of posts are extracted?

Text posts, photo posts, video posts, link shares, live videos, reels, and shared posts from public pages and profiles.

#### 📅 How far back can I scrape?

Up to **10 years** of post history (3,650 days). The scraper maintains full speed regardless of depth — post #5,000 loads as fast as post #1.

#### 🔍 Can I filter posts by keyword or date?

The scraper collects all posts within your `daysBack` range. Use the exported data to filter by keyword, date, engagement threshold, or any field in your analysis tool.

#### 🔄 Does it handle Facebook pages that post very frequently?

Yes. The engine automatically detects high-frequency pages and optimizes for maximum throughput. News pages posting 50+ times per day run at full speed.

#### 📉 What about pages that post rarely?

Yes. The engine adapts to low-frequency pages too. A page posting once a week is scraped just as efficiently as one posting hourly — no wasted time on inactive periods.

#### ⚖️ Is scraping Facebook posts legal?

This scraper only accesses publicly visible data. Always review Facebook's Terms of Service and applicable data protection regulations (GDPR, CCPA) before using scraped data commercially.

# Actor input Schema

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

Full Facebook page or profile URLs. Example: https://www.facebook.com/Meta

## `usernames` (type: `array`):

Facebook usernames or handles. With or without @. Example: cnn, @Meta, zuck

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

Maximum number of posts to scrape per page. Set to 10000 for full history extraction.

## Actor input object example

```json
{
  "pageUrls": [
    "https://www.facebook.com/Meta"
  ],
  "usernames": [],
  "maxPostsPerPage": 10
}
```

# 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 = {
    "pageUrls": [
        "https://www.facebook.com/Meta"
    ],
    "usernames": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/facebook-posts-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 = {
    "pageUrls": ["https://www.facebook.com/Meta"],
    "usernames": [],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/facebook-posts-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 '{
  "pageUrls": [
    "https://www.facebook.com/Meta"
  ],
  "usernames": []
}' |
apify call scrapesmith/facebook-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Posts Scraper",
        "description": "🔥$0.7/1000 results🔥 Scrape posts from any public Facebook page or profile. Extract post text, reactions, comments count, shares, timestamps, and author details. 350+ posts/min. Scrape 10 years history. Export as JSON, CSV, Excel. API, MCP, and webhook ready for Claude, ChatGPT, and AI agents.",
        "version": "0.0",
        "x-build-id": "Q9RqlsO0608laPvTb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~facebook-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-facebook-posts-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/scrapesmith~facebook-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-facebook-posts-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/scrapesmith~facebook-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-facebook-posts-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": {
                    "pageUrls": {
                        "title": "Page URLs",
                        "type": "array",
                        "description": "Full Facebook page or profile URLs. Example: https://www.facebook.com/Meta",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Facebook usernames or handles. With or without @. Example: cnn, @Meta, zuck",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerPage": {
                        "title": "Max Posts Per Page",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape per page. Set to 10000 for full history extraction.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```