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

Scrape public Facebook posts, reels, videos, and visible engagement data from pages, profiles, and public groups. Unofficial actor, not affiliated with Facebook or Meta.

- **URL**: https://apify.com/netdesignr/facebook-posts-scraper.md
- **Developed by:** [Netdesignr](https://apify.com/netdesignr) (community)
- **Categories:** Social media
- **Stats:** 88 total users, 9 monthly users, 99.1% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.00 / 1,000 posts

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Facebook Posts Scraper

Scrape public Facebook posts, reels, videos, and engagement data from pages, profiles, and public groups. This [Apify actor](https://apify.com/actors) is designed for lower-cost public-surface extraction, cleaner pricing, and API-first workflows without requiring a Facebook login.

Pages, profiles, groups, reels | No login | Keyword filters | API-ready | AI workflow friendly

### Why use this Facebook scraper

- Extract public Facebook posts from pages, profiles, and public groups.
- Capture reels and video post URLs alongside captions, thumbnails, and visible engagement.
- Filter by keyword and date without making users pay an extra add-on for date filtering.
- Choose `fast`, `balanced`, or `full` extraction depending on cost and depth.
- Export results to JSON, CSV, Excel, XML, RSS, or any dataset format supported by Apify.
- Run on demand, schedule recurring runs, or call it through the Apify API from your own app.

### What data can I extract with Facebook Posts Scraper?

Use this actor to collect the public post data most teams actually need for monitoring, reporting, and content analysis.

| Source and post identity | Content and media | Engagement and diagnostics |
| --- | --- | --- |
| Source type such as `page`, `profile`, or `group` | Post text and reel captions | Visible reaction totals |
| Source name and canonical Facebook URL | Hashtags, links, and visible text references | Visible comment counts |
| Post ID and clean post URL | Image URLs, thumbnails, and media assets | Visible share counts |
| Publish time and visible time label like `19h` or `2d` | Video metadata when Facebook exposes it | Top comment previews when enabled |
| Page or profile details such as category, intro, and website | Reel, photo, video, and mixed-media post coverage | Honest warnings when Facebook hides or degrades fields |

Detailed output fields include `sourceType`, `sourceName`, `canonicalSourceUrl`, `postId`, `postUrl`, `time`, `timeText`, `text`, `textReferences`, `totalReactions`, `comments`, `shares`, `media`, `thumbnails`, `video`, `topCommentsPreview`, `page`, and `warnings`.

### What makes this actor different

- Public-surface first: built around logged-out Facebook pages, profiles, reels, and groups that are visible without a session.
- Cleaner pricing model: meant to launch with one simple per-result price instead of charging extra for date filters.
- Better control: `fast`, `balanced`, and `full` modes let users tune speed and cost.
- Better observability: every run stores `RUN_META` so operators can audit empty runs, retries, and failures.
- Better output hygiene: tracking parameters are removed from Facebook URLs before results are stored.

### Example workflows and case-study use cases

- Brand monitoring: track the latest posts and reels from competitor pages each morning and export them into Slack, Sheets, or your warehouse.
- Hospitality marketing: monitor hotel, resort, and venue pages to compare post cadence, reel usage, and visible engagement across markets.
- Lead research: pull public posts from local businesses, creators, or communities and use visible links and hashtags to enrich outreach lists.
- AI knowledge pipelines: schedule daily runs and feed cleaned Facebook post data into retrieval, summarization, or agent workflows.

### How to scrape Facebook posts

1. Open this actor in Apify Store and click **Try for free**.
2. Paste one or more Facebook page, profile, or group URLs into `startUrls`.
3. Set `maxPosts` and choose `fast`, `balanced`, or `full`.
4. Optionally add `keywordFilter`, `dateFrom`, `dateTo`, or top comment previews.
5. Start the run and export the dataset in the format you need.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | `[]` | Main list of Facebook pages, profiles, or public groups |
| `pageOrProfileUrls` | array | `[]` | Shortcut list for pages and profiles |
| `groupUrls` | array | `[]` | Shortcut list for public Facebook groups |
| `maxPosts` | integer | `5` | Maximum posts emitted across all targets |
| `dateFrom` | string | none | Keep posts on or after `YYYY-MM-DD` |
| `dateTo` | string | none | Keep posts on or before `YYYY-MM-DD` |
| `keywordFilter` | array | none | Only keep posts whose visible text matches one of the keywords |
| `extractionMode` | string | `fast` | `fast`, `balanced`, or `full` |
| `includeTopComments` | boolean | `false` | Include visible top comments when Facebook shows them |
| `commentPreviewLimit` | integer | `2` | Max visible comment previews per post |
| `includeTranscripts` | boolean | `false` | Best-effort video transcript extraction in richer runs |
| `deduplicate` | boolean | `true` | Remove duplicates across overlapping sources |
| `proxyConfiguration` | object | none | Optional user-supplied proxy configuration; no proxy is used by default |
| `residentialProxyFallbackMode` | string | `off` | Automatic residential fallback is disabled for cost control; legacy `retry` inputs are treated as `off` |
| `debugMode` | boolean | `false` | Adds extra diagnostics for troubleshooting |
| `emptyRunPolicy` | string | `retry_then_warn` | Controls exit behavior when a reachable public surface emits zero posts; runs where every target errors still fail |

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/NASA" }
  ],
  "maxPosts": 5,
  "extractionMode": "fast",
  "dateFrom": "2026-03-01",
  "keywordFilter": ["design", "launch", "website"],
  "includeTopComments": false,
  "commentPreviewLimit": 2
}
````

### Output example

```json
{
  "sourceType": "page",
  "sourceName": "NetDesignr",
  "canonicalSourceUrl": "https://www.facebook.com/netdesignr",
  "postId": "pfbidExample123",
  "postUrl": "https://www.facebook.com/netdesignr/posts/pfbidExample123",
  "time": "2026-03-17T18:40:00.000Z",
  "timeText": "19h",
  "text": "We just launched a new website performance and UX audit workflow for growing brands.",
  "totalReactions": 14,
  "comments": 3,
  "shares": 1,
  "warnings": ["timestamp_estimated_from_relative_time"],
  "scrapedAt": "2026-03-18T17:42:00.000Z"
}
```

### Facebook scraper API examples

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('netdesignr/facebook-posts-scraper').call({
  startUrls: [{ url: 'https://www.facebook.com/NASA' }],
  maxPosts: 5,
  extractionMode: 'fast',
  includeTopComments: false,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("netdesignr/facebook-posts-scraper").call(run_input={
    "startUrls": [{"url": "https://www.facebook.com/NASA"}],
    "maxPosts": 5,
    "extractionMode": "fast",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/netdesignr~facebook-posts-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.facebook.com/NASA"}],
    "maxPosts": 5,
    "extractionMode": "fast"
  }'
```

### Pricing and monetization

This actor uses simple per-result pricing based on dataset items. The pricing model is designed to stay straightforward, with no separate add-on fee for date filtering.

### FAQ

#### Can I scrape Facebook pages without logging in?

Yes, for public surfaces that Facebook exposes to logged-out browsers. Private or restricted pages, groups, and profiles may return partial or empty data.

#### Does this actor support Facebook reels?

Yes. Reels are extracted as Facebook post URLs and marked as video media when they are visible on the public page.

#### Can I filter by date?

Yes. `dateFrom` and `dateTo` work against the visible publish time that Facebook exposes on public surfaces. When Facebook only shows relative times such as `19h`, the actor stores an estimated timestamp and a warning.

#### Do I need proxies?

Not always. Many public pages work without them, and this actor never enables residential proxies automatically. Add an explicit proxy configuration only when the reliability need justifies the extra traffic cost.

#### Can I use this as a Facebook API alternative?

Yes, for public post collection, competitor monitoring, research, and content analysis. This actor is useful when you need public Facebook post data without building and maintaining your own scraper stack.

#### What are the main limitations?

Exact timestamps, full reaction breakdowns, and transcripts depend on what Facebook exposes publicly. The actor does not invent missing values and reports partial-visibility warnings instead.

### Legal and responsible use

Use this actor only for data you have the right to collect and process. Respect Facebook's terms, local law, privacy obligations, and any downstream compliance requirements such as GDPR or CCPA. Review Apify's documentation and your legal requirements before using scraped public data in production.

# Actor input Schema

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

Facebook page, profile, or public group URLs to scrape for posts, reels, videos, and visible engagement data.

## `pageOrProfileUrls` (type: `array`):

Shortcut list for Facebook page or profile URLs when you do not want to use Start URLs.

## `groupUrls` (type: `array`):

Shortcut list for public Facebook group URLs that expose posts to logged-out users.

## `maxPosts` (type: `integer`):

Maximum number of posts to emit across all targets in this run.

## `dateFrom` (type: `string`):

Only keep posts on or after this date. Format: YYYY-MM-DD. Works against the visible public timestamp Facebook exposes.

## `dateTo` (type: `string`):

Only keep posts on or before this date. Format: YYYY-MM-DD. Works against the visible public timestamp Facebook exposes.

## `keywordFilter` (type: `array`):

Only keep posts whose visible text matches one of these keywords. Useful for campaign tracking, lead research, and monitoring.

## `extractionMode` (type: `string`):

Fast mode minimizes work and cost, balanced mode captures richer output, and full mode performs best-effort post detail enrichment.

## `includeTopComments` (type: `boolean`):

Include visible top comments from the public post card when available.

## `commentPreviewLimit` (type: `integer`):

How many visible top comments to keep per post when previews are available.

## `includeTranscripts` (type: `boolean`):

Best-effort transcript extraction for videos in richer runs. Transcript availability depends on what Facebook exposes publicly.

## `deduplicate` (type: `boolean`):

Remove duplicates across overlapping inputs and repeated Facebook cards.

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

Optional proxy configuration supplied by the user. No proxy is used by default, and the Actor never enables residential proxies automatically.

## `residentialProxyFallbackMode` (type: `string`):

Automatic residential proxy fallback is disabled for cost control. Existing saved tasks that send Retry are treated as Off.

## `debugMode` (type: `boolean`):

Include extra warnings and technical information for troubleshooting and selector debugging.

## `emptyRunPolicy` (type: `string`):

How the actor should exit when a reachable public surface yields zero posts. Runs where every target errors still fail.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/NASA"
    }
  ],
  "maxPosts": 5,
  "extractionMode": "fast",
  "includeTopComments": false,
  "commentPreviewLimit": 2,
  "includeTranscripts": false,
  "deduplicate": true,
  "residentialProxyFallbackMode": "off",
  "debugMode": false,
  "emptyRunPolicy": "retry_then_warn"
}
```

# Actor output Schema

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

No description

## `detailed` (type: `string`):

No description

## `engagement` (type: `string`):

No description

## `media` (type: `string`):

No description

## `sources` (type: `string`):

No description

# API

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

## JavaScript example

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

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

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

// Run the Actor and wait for it to finish
const run = await client.actor("netdesignr/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 = { "startUrls": [{ "url": "https://www.facebook.com/NASA" }] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Posts Scraper",
        "description": "Scrape public Facebook posts, reels, videos, and visible engagement data from pages, profiles, and public groups. Unofficial actor, not affiliated with Facebook or Meta.",
        "version": "0.3",
        "x-build-id": "lst4lFcaObEdqGLIv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/netdesignr~facebook-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-netdesignr-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/netdesignr~facebook-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-netdesignr-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/netdesignr~facebook-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-netdesignr-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Facebook page, profile, or public group URLs to scrape for posts, reels, videos, and visible engagement data.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "pageOrProfileUrls": {
                        "title": "Pages / Profiles",
                        "type": "array",
                        "description": "Shortcut list for Facebook page or profile URLs when you do not want to use Start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "groupUrls": {
                        "title": "Group URLs",
                        "type": "array",
                        "description": "Shortcut list for public Facebook group URLs that expose posts to logged-out users.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPosts": {
                        "title": "Max posts",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of posts to emit across all targets in this run.",
                        "default": 5
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Only keep posts on or after this date. Format: YYYY-MM-DD. Works against the visible public timestamp Facebook exposes."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Only keep posts on or before this date. Format: YYYY-MM-DD. Works against the visible public timestamp Facebook exposes."
                    },
                    "keywordFilter": {
                        "title": "Keyword filter",
                        "type": "array",
                        "description": "Only keep posts whose visible text matches one of these keywords. Useful for campaign tracking, lead research, and monitoring.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extractionMode": {
                        "title": "Extraction mode",
                        "enum": [
                            "fast",
                            "balanced",
                            "full"
                        ],
                        "type": "string",
                        "description": "Fast mode minimizes work and cost, balanced mode captures richer output, and full mode performs best-effort post detail enrichment.",
                        "default": "fast"
                    },
                    "includeTopComments": {
                        "title": "Include top comments preview",
                        "type": "boolean",
                        "description": "Include visible top comments from the public post card when available.",
                        "default": false
                    },
                    "commentPreviewLimit": {
                        "title": "Comment preview limit",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many visible top comments to keep per post when previews are available.",
                        "default": 2
                    },
                    "includeTranscripts": {
                        "title": "Include transcripts",
                        "type": "boolean",
                        "description": "Best-effort transcript extraction for videos in richer runs. Transcript availability depends on what Facebook exposes publicly.",
                        "default": false
                    },
                    "deduplicate": {
                        "title": "Deduplicate posts",
                        "type": "boolean",
                        "description": "Remove duplicates across overlapping inputs and repeated Facebook cards.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy configuration supplied by the user. No proxy is used by default, and the Actor never enables residential proxies automatically."
                    },
                    "residentialProxyFallbackMode": {
                        "title": "Residential proxy fallback",
                        "enum": [
                            "off"
                        ],
                        "type": "string",
                        "description": "Automatic residential proxy fallback is disabled for cost control. Existing saved tasks that send Retry are treated as Off.",
                        "default": "off"
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Include extra warnings and technical information for troubleshooting and selector debugging.",
                        "default": false
                    },
                    "emptyRunPolicy": {
                        "title": "Empty run policy",
                        "enum": [
                            "retry_then_fail",
                            "retry_then_succeed",
                            "retry_then_warn"
                        ],
                        "type": "string",
                        "description": "How the actor should exit when a reachable public surface yields zero posts. Runs where every target errors still fail.",
                        "default": "retry_then_warn"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
