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

👥 Facebook Groups Scraper (facebook-groups-scraper) pulls posts, comments, reactions, member info (where permitted) & keywords from public or authorized groups—fast and at scale. 📊 Gain trend insights, audience profiles, and content ideas. 🚀 Ideal for research, analytics & lead discovery.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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!

## `cookieString` (type: `string`):

📋 **How to get your cookies:**

1. Log into Facebook in your browser
2. Open DevTools → **Application** → **Cookies** → `https://www.facebook.com`
3. Copy the cookie header (must include at least `c_user` and `xs`)

📝 **Format:** `c_user=100000...; xs=12%3A...; datr=...; fr=...`

⚠️ **Privacy:** Use a dedicated/secondary account. Cookies grant access to that account.

💡 **Tip:** Leave empty to attempt logged-out (public-only) scraping via residential proxy.

## Actor input object example

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

# 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": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapium/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": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapium/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": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapium/facebook-groups-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Groups Scraper",
        "description": "👥 Facebook Groups Scraper (facebook-groups-scraper) pulls posts, comments, reactions, member info (where permitted) & keywords from public or authorized groups—fast and at scale. 📊 Gain trend insights, audience profiles, and content ideas. 🚀 Ideal for research, analytics & lead discovery.",
        "version": "0.1",
        "x-build-id": "WcenzWVwVVGOEbyhW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~facebook-groups-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-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/scrapium~facebook-groups-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-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/scrapium~facebook-groups-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-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!"
                    },
                    "cookieString": {
                        "title": "🍪 Facebook Cookie String",
                        "type": "string",
                        "description": "📋 **How to get your cookies:**\n\n1. Log into Facebook in your browser\n2. Open DevTools → **Application** → **Cookies** → `https://www.facebook.com`\n3. Copy the cookie header (must include at least `c_user` and `xs`)\n\n📝 **Format:** `c_user=100000...; xs=12%3A...; datr=...; fr=...`\n\n⚠️ **Privacy:** Use a dedicated/secondary account. Cookies grant access to that account.\n\n💡 **Tip:** Leave empty to attempt logged-out (public-only) scraping via residential proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```