# Facebook Groups Scraper (`scraperx/facebook-groups-scraper`) Actor

- **URL**: https://apify.com/scraperx/facebook-groups-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

A powerful Apify actor to scrape Facebook group posts with automatic discovery of doc_id, node_id, and end_cursor, intelligent pagination, advanced filtering options, and smart proxy management.

### Key Features

- 🔍 **Automatic Discovery**: Extracts node_id, doc_id, and end_cursor automatically from group HTML/JS
- 📄 **Smart Pagination**: Paginates through group feed and streams results to Apify dataset in real-time
- 🏠 **Residential Proxy**: Always uses residential proxy with automatic retries until data demand is fulfilled
- 🔄 **Multiple Sorting Options**: Support for CHRONOLOGICAL, RECENT_ACTIVITY, TOP_POSTS, and CHRONOLOGICAL_LISTINGS
- 🔎 **Advanced Filtering**: Filter posts by keywords, year, and date range
- ⚡ **Anti-blocking**: Randomized delays between requests to avoid detection
- 📊 **Rich Data Extraction**: Extracts posts with reactions, comments, attachments, and metadata

### Input Parameters

#### Required

- **`startUrls`** (array, required): Facebook group URLs to scrape
  - Only public Facebook groups can be scraped
  - Example: `["https://www.facebook.com/groups/example-group"]`

#### Optional

- **`resultsLimit`** (integer, default: 20): Maximum number of posts to scrape across all URLs
  - Minimum: 1
  - If not set, the actor will scrape as many results as possible

- **`viewOption`** (string, default: "CHRONOLOGICAL"): Sorting order for posts
  - Options:
    - `CHRONOLOGICAL`: Posts in chronological order
    - `RECENT_ACTIVITY`: Posts sorted by recent activity
    - `TOP_POSTS`: Top posts by engagement
    - `CHRONOLOGICAL_LISTINGS`: Chronological listings (for BuySell groups)
  - Note: The results limit applies to new posts only

- **`searchGroupKeyword`** (string): Search posts by letter or keyword
  - ⚠️ **Important**: Without logging in, search results are VERY limited
  - Searching by full words will return nothing in most cases
  - **Recommendation**: Use one or two letter searches for better results
  - Example: `"a"` or `"ab"`

- **`searchGroupYear`** (string): Filter posts by specific year
  - Requires `searchGroupKeyword` to be set
  - Example: `"2024"`

- **`onlyPostsNewerThan`** (string): Filter posts newer than a specific date/time
  - Supports multiple formats:
    - **Absolute date**: `"2024-01-15"` or `"2024-01-15T10:30:00"`
    - **Relative time**: `"1 days"`, `"2 months"`, `"3 years"`, `"1 hour"`, `"2 minutes"`
    - **ISO format**: `"2024-01-15T10:30:00Z"`
  - Examples:
    - `"2024-01-15"` - Posts from January 15, 2024 onwards
    - `"2 months"` - Posts from the last 2 months
    - `"1 days"` - Posts from the last 24 hours

- **`proxyConfiguration`** (object): Proxy settings
  - Actor always uses residential proxy
  - Automatically retries until user demand data is fully fulfilled
  - Default: `{"useApifyProxy": false}`

### Output Structure

Each post in the dataset contains the following fields:

#### Basic Information
- **`facebookUrl`**: URL of the Facebook group
- **`url`**: Direct URL to the post
- **`time`**: ISO8601 timestamp when the post was created (UTC, `.000Z` format)
- **`inputUrl`**: Original input URL used for scraping

#### Post Identifiers
- **`id`**: Unique post identifier
- **`legacyId`**: Legacy post ID (post_id)
- **`feedbackId`**: Feedback identifier for the post

#### User Information
- **`user`**: Object containing:
  - `id`: User ID
  - `name`: User's display name

#### Content
- **`text`**: Post text content
- **`attachments`**: Array of attachments including:
  - Photos with thumbnail, image URI, dimensions
  - Media sets (albums) with mediaset_token
  - OCR text from images
  - Owner information

#### Engagement Metrics
- **`likesCount`**: Total number of likes
- **`sharesCount`**: Total number of shares
- **`commentsCount`**: Total number of comments
- **`topReactionsCount`**: Total count of top reactions
- **`reactionLikeCount`**: Number of like reactions
- **`reactionLoveCount`**: Number of love reactions

#### Comments
- **`topComments`**: Array of top 2 comments, each containing:
  - `commentUrl`: Direct URL to the comment
  - `id`: Comment identifier
  - `feedbackId`: Comment feedback ID
  - `date`: Comment timestamp
  - `text`: Comment text
  - `profileUrl`: Commenter's profile URL
  - `profilePicture`: Commenter's profile picture URL
  - `profileId`: Commenter's user ID
  - `profileName`: Commenter's display name
  - `likesCount`: Number of likes on the comment
  - `threadingDepth`: Comment threading depth

#### Group Information
- **`facebookId`**: Facebook group ID
- **`groupTitle`**: Title of the Facebook group
- **`pageAdLibrary`**: Object containing:
  - `is_business_page_active`: Boolean flag
  - `id`: Page/group identifier

### How to Use

1. **Open the Actor**: In Apify Console, navigate to the Facebook Groups Scraper actor

2. **Configure Input**:
   - Add one or more Facebook group URLs in `startUrls`
   - (Optional) Set `resultsLimit` to control how many posts to scrape
   - (Optional) Choose `viewOption` for sorting preference
   - (Optional) Set `searchGroupKeyword` and `searchGroupYear` for filtered searches
   - (Optional) Set `onlyPostsNewerThan` to filter by date

3. **Run the Actor**: Click "Start" and monitor the logs for progress

4. **View Results**: 
   - Results are streamed to the dataset in real-time
   - View in the OUTPUT tab
   - Export as JSON, CSV, or other formats as needed

### Example Input

```json
{
  "startUrls": [
    "https://www.facebook.com/groups/germtheory.vs.terraintheory"
  ],
  "resultsLimit": 100,
  "viewOption": "RECENT_ACTIVITY",
  "searchGroupKeyword": "a",
  "searchGroupYear": "2024",
  "onlyPostsNewerThan": "2 months"
}
````

### Important Notes

- **Public Groups Only**: Only public Facebook groups can be scraped without authentication
- **Search Limitations**: Without logging in, search functionality is very limited. Use single or double letters for best results
- **Proxy Policy**: The actor always uses residential proxy and will automatically retry until your data demand is fulfilled
- **Real-time Streaming**: Results are saved to the dataset as they are extracted, not at the end
- **Date Filtering**: Date filters are applied client-side after extraction
- **Rate Limiting**: The actor includes anti-blocking delays between requests

### Support

For custom solutions, feature requests, or technical support, please contact:
📧 **dev.scraperengine@gmail.com**

### Technical Details

- **Automatic Discovery**: The actor automatically extracts required GraphQL parameters (doc\_id, node\_id, end\_cursor) from Facebook's HTML and JavaScript
- **Pagination**: Uses cursor-based pagination to navigate through group feeds
- **Error Handling**: Includes retry logic and fallback mechanisms for robust scraping
- **Data Normalization**: All extracted data is normalized to a consistent structure matching the output schema

# Actor input Schema

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

📌 **Add Your Target Groups** 📌

✨ Paste one or more public Facebook group URLs here.

⚠️ **Important:** Only public groups are supported. Private groups require authentication.

💡 **Tip:** You can scrape multiple groups in one run!

## `resultsLimit` (type: `integer`):

🎯 **Control Your Data Volume** 🎯

Set the maximum number of posts to scrape from each group.

💡 **Smart Tip:** Leave empty to scrape ALL available posts (perfect for comprehensive analysis, but may take longer).

⚡ **Recommended:** Start with 20-50 posts to test, then scale up!

## `viewOption` (type: `string`):

🎭 **Choose Your Sorting Style** 🎭

Select how posts should be organized and displayed:

📅 **Chronological** - Time-travel through posts (oldest → newest)

🔥 **Recent Activity** - Catch the hottest, most active discussions

⭐ **Top Posts** - Discover the most popular and engaging content

🛒 **Chronological Listings** - Perfect for Buy/Sell groups

⚠️ **Note:** Post limit applies to 'New posts' sorting only.

## `searchGroupKeyword` (type: `string`):

🎯 **Find Specific Content** 🎯

Search posts by keyword or letter to filter results.

⚠️ **Limitation:** Without login, search capabilities are limited.

💡 **Pro Strategy:**
• Use 1-2 letters + year filter for optimal results
• Combine with year filter below for precision

📝 **Note:** Full words may not return results in most cases.

## `searchGroupYear` (type: `string`):

🗓️ **Time-Travel to Specific Years** 🗓️

Filter posts from a specific year (e.g., 2024, 2023, 2022).

📌 **Important:** Must be used together with the Search Keyword field above for best results.

💡 **Example:** Enter "2024" to get posts from that year only.

## `onlyPostsNewerThan` (type: `string`):

⏰ **Set Your Time Boundary** ⏰

Stop scraping when posts are older than this date.

📝 **Format Options:**
• **Absolute:** YYYY-MM-DD (e.g., 2024-01-15)
• **Relative:** Natural language (e.g., "2 weeks", "7 days", "1 month")

💡 **Examples:**
• "2024-01-01" - Posts from January 2024 onwards
• "30 days" - Posts from the last month
• "1 year" - Posts from the last year

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

🛡️ **Enterprise-Grade Security** 🛡️

Configure proxy settings for secure and reliable scraping.

✨ **Features:**
• ✅ Automatic residential proxy rotation
• 🔄 Smart auto-retry mechanism
• 🚀 Ensures complete data collection
• 🔒 Protects your scraping activities

💡 **Recommended:** Enable for large-scale scraping operations!

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/groups/cheapmealideas/"
  ],
  "resultsLimit": 10,
  "viewOption": "CHRONOLOGICAL",
  "searchGroupKeyword": "",
  "searchGroupYear": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.facebook.com/groups/cheapmealideas/"
    ],
    "onlyPostsNewerThan": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": ["https://www.facebook.com/groups/cheapmealideas/"],
    "onlyPostsNewerThan": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.facebook.com/groups/cheapmealideas/"
  ],
  "onlyPostsNewerThan": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperx/facebook-groups-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Groups Scraper",
        "version": "0.1",
        "x-build-id": "YCeinGcav1k7aNvxF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~facebook-groups-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-facebook-groups-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/scraperx~facebook-groups-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-facebook-groups-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/scraperx~facebook-groups-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-facebook-groups-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Facebook Group URLs",
                        "type": "array",
                        "description": "📌 **Add Your Target Groups** 📌\n\n✨ Paste one or more public Facebook group URLs here.\n\n⚠️ **Important:** Only public groups are supported. Private groups require authentication.\n\n💡 **Tip:** You can scrape multiple groups in one run!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "📊 Number of Posts to Scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🎯 **Control Your Data Volume** 🎯\n\nSet the maximum number of posts to scrape from each group.\n\n💡 **Smart Tip:** Leave empty to scrape ALL available posts (perfect for comprehensive analysis, but may take longer).\n\n⚡ **Recommended:** Start with 20-50 posts to test, then scale up!",
                        "default": 10
                    },
                    "viewOption": {
                        "title": "🔄 Post Sorting Strategy",
                        "enum": [
                            "CHRONOLOGICAL",
                            "RECENT_ACTIVITY",
                            "TOP_POSTS",
                            "CHRONOLOGICAL_LISTINGS"
                        ],
                        "type": "string",
                        "description": "🎭 **Choose Your Sorting Style** 🎭\n\nSelect how posts should be organized and displayed:\n\n📅 **Chronological** - Time-travel through posts (oldest → newest)\n\n🔥 **Recent Activity** - Catch the hottest, most active discussions\n\n⭐ **Top Posts** - Discover the most popular and engaging content\n\n🛒 **Chronological Listings** - Perfect for Buy/Sell groups\n\n⚠️ **Note:** Post limit applies to 'New posts' sorting only.",
                        "default": "CHRONOLOGICAL"
                    },
                    "searchGroupKeyword": {
                        "title": "🔍 Search Keyword Filter",
                        "type": "string",
                        "description": "🎯 **Find Specific Content** 🎯\n\nSearch posts by keyword or letter to filter results.\n\n⚠️ **Limitation:** Without login, search capabilities are limited.\n\n💡 **Pro Strategy:** \n• Use 1-2 letters + year filter for optimal results\n• Combine with year filter below for precision\n\n📝 **Note:** Full words may not return results in most cases.",
                        "default": ""
                    },
                    "searchGroupYear": {
                        "title": "📅 Year Filter",
                        "type": "string",
                        "description": "🗓️ **Time-Travel to Specific Years** 🗓️\n\nFilter posts from a specific year (e.g., 2024, 2023, 2022).\n\n📌 **Important:** Must be used together with the Search Keyword field above for best results.\n\n💡 **Example:** Enter \"2024\" to get posts from that year only.",
                        "default": ""
                    },
                    "onlyPostsNewerThan": {
                        "title": "📅 Posts Newer Than",
                        "pattern": "^$|^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "⏰ **Set Your Time Boundary** ⏰\n\nStop scraping when posts are older than this date.\n\n📝 **Format Options:**\n• **Absolute:** YYYY-MM-DD (e.g., 2024-01-15)\n• **Relative:** Natural language (e.g., \"2 weeks\", \"7 days\", \"1 month\")\n\n💡 **Examples:**\n• \"2024-01-01\" - Posts from January 2024 onwards\n• \"30 days\" - Posts from the last month\n• \"1 year\" - Posts from the last year"
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy & Security Settings",
                        "type": "object",
                        "description": "🛡️ **Enterprise-Grade Security** 🛡️\n\nConfigure proxy settings for secure and reliable scraping.\n\n✨ **Features:**\n• ✅ Automatic residential proxy rotation\n• 🔄 Smart auto-retry mechanism\n• 🚀 Ensures complete data collection\n• 🔒 Protects your scraping activities\n\n💡 **Recommended:** Enable for large-scale scraping operations!"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```