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

Drop-in compatible Facebook Pages Scraper, ~37% cheaper than the upstream. Extracts title, intro, address, phone, website, messenger, likes, followers, rating, ad status, opening hours, and services. Adds extractedAt provenance and forced en\_US locale.

- **URL**: https://apify.com/prodiger/facebook-pages-scraper.md
- **Developed by:** [Arnas](https://apify.com/prodiger) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 9 total users, 4 monthly users, 98.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### What does Facebook Pages Scraper do?

**Facebook Pages Scraper extracts public data from Facebook Pages and Profiles** — title, intro, address, phone, website, messenger link, likes, followers, rating, ad-running status, profile and cover photos, page creation date, page-ad-library ID, and more. It's a **drop-in compatible, lower-cost alternative to the most-installed Facebook Pages Scraper** on Apify Store. Same `startUrls` input, same field names in the output, **~37 % lower cost** at typical run sizes.

It also adds three things the upstream actor doesn't:

- **`extractedAt` provenance** on every record (ISO-8601 UTC) — drop into change-detection pipelines without fabricating timestamps.
- **`openingHours`** — structured per-day open/close times for local-business pages.
- **`services`** — string array of services offered, when the page lists them.

The actor forces `?locale=en_US` on every request so labels and field text stay stable across runs regardless of the proxy IP's geo.

### Why use this scraper?

- 💰 **~37 % cheaper at scale** — $7.50 / 1,000 pages vs $12 / 1,000 on the upstream alternative
- 🔁 **Drop-in compatible** — paste your existing input and swap the actor ID, no code changes
- 🌍 **Stable labels** — forced `en_US` locale eliminates a whole class of silent extraction failure
- 🕒 **Structured opening hours** — per-day open/close as parseable JSON, not free-text
- 🛠 **Services list** — useful for local-business lead enrichment
- 📅 **`extractedAt`** on every record — provenance for downstream change detection
- 📤 **Standard Apify output** — JSON, CSV, Excel, HTML, plus REST API access

### Who is it for?

**Lead-gen teams scraping Facebook for B2B prospecting**

- 🗂 Build a list of local businesses by Page URL, enrich with phone/email/website
- 📞 Capture Messenger links, opening hours, and services for outbound outreach

**Market researchers monitoring brand pages**

- 📈 Track follower / like counts over time using the `extractedAt` field
- 📰 Detect when a brand starts running ads via `ad_status`

**Developers building Facebook data pipelines**

- 🤖 Integrate via the Apify API; output is identical to `apify/facebook-pages-scraper`
- 🧩 Feed results into HubSpot, Salesforce, Airtable via Make or Zapier

### What data can you extract?

Output is one record per Facebook page. Top-level fields (`facebookUrl` through `pageAdLibrary`) match the upstream Facebook Pages Scraper field-for-field; the four additive fields appear at the bottom.

| Field | Example |
|---|---|
| `facebookUrl` | `"https://www.facebook.com/copperkettleyqr"` |
| `pageUrl` | `"https://www.facebook.com/copperkettleyqr"` |
| `pageName` | `"copperkettleyqr"` |
| `title` | `"Copper Kettle"` |
| `pageId` / `facebookId` | `"100075002413577"` |
| `categories` | `["Restaurant", "Local Business"]` |
| `info` | `["1,948 likes", "Tea room and gift shop in Regina..."]` |
| `intro` | `"Tea room and gift shop in Regina serving locally sourced food."` |
| `likes` / `followers` | `1948` / `2041` |
| `messenger` | `"https://m.me/copperkettleyqr"` or `null` |
| `address` | `"1953 Scarth St, Regina, SK, S4P 2H1, Canada"` |
| `phone` | `"+1-306-525-3545"` |
| `website` | `"www.copperkettle.ca"` |
| `email` | `"hello@copperkettle.ca"` |
| `rating` / `ratingOverall` / `ratingCount` | `"94% recommend (238 Reviews)"` / `94` / `238` |
| `profilePictureUrl` / `coverPhotoUrl` | URLs |
| `creation_date` | `"March 15, 2014"` |
| `ad_status` | `"This Page is currently running ads."` |
| `confirmed_owner` / `CONFIRMED_OWNER_LABEL` | when present |
| `pageAdLibrary` | `{ is_business_page_active: true, id: "1234567890123456" }` |
| **`openingHours`** | `[{ day: "monday", open: "09:00", close: "17:00" }, ...]` |
| **`services`** | `["Dine-in", "Takeout", "Catering"]` |
| **`extractedAt`** | `"2026-05-16T12:00:00.000Z"` |
| **`actorVersion`** | `"0.1.0"` |

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

This Actor uses **pay-per-event pricing**. You pay only for pages that actually returned data. Block walls, login redirects, and timeouts never bill.

| Event | Free | Bronze ($29/mo) | Silver ($199/mo) | Gold ($999/mo) |
|---|---|---|---|---|
| Run started (once per run) | $0.005 | $0.0047 | $0.0043 | $0.00375 |
| Per page scraped | $0.0075 | $0.00705 | $0.00645 | $0.005625 |

**Real-world cost examples (Free tier):**

| Pages scraped | Cost (this actor) | Cost (upstream at $12/1000) | Savings |
|---|---|---|---|
| 1 page | ~$0.013 | $0.012 | — |
| 100 pages | ~$0.755 | $1.20 | ~37 % |
| 1,000 pages | ~$7.51 | $12.00 | ~37 % |
| 10,000 pages | ~$75.01 | $120.00 | ~37 % |

> The "actor-start" charge is intentionally tiny so 1-page test runs cost almost nothing. Bulk runs pay almost entirely the per-page rate.

### How to use Facebook Pages Scraper

1. Click **Try for free** on the Actor page (no credit card needed for the free $5 credit).
2. Paste a list of Facebook page URLs into **Facebook Page URLs** — one per line. Bare slugs like `humansofnewyork` are auto-rewritten to `https://www.facebook.com/humansofnewyork`.
3. Leave **Concurrent page loads** at `2` (Facebook rate-limits hard — going higher trades cost for stability).
4. Leave **Proxy configuration** at the default (residential proxies are auto-selected).
5. Click **Start**. Results appear in the **Output** tab as they're scraped.

### Input

Configure the actor on the **Input** tab in the Apify Console. All fields except `startUrls` are optional and have sensible defaults.

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array of `{ url }` objects | required | Facebook page URLs. Bare slugs (`humansofnewyork`) are auto-rewritten to canonical URLs. Personal profiles work but return fewer fields than Pages. |
| `maxConcurrency` | integer | `2` | Parallel page loads. Facebook rate-limits hard — keep this at 2 unless you have a specific reason to raise it. |
| `requestTimeoutSecs` | integer | `60` | Per-page timeout before Crawlee retries with a fresh session. |
| `proxyConfiguration` | object | `{ useApifyProxy: true, apifyProxyGroups: ["RESIDENTIAL"] }` | Apify proxy settings. Residential is strongly recommended — datacenter IPs are blocked within a few requests. `proxyUrls` entries pointing at private / loopback / link-local hosts are rejected at input parsing. |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/humansofnewyork" },
    { "url": "https://www.facebook.com/nasaearth" }
  ],
  "maxConcurrency": 2,
  "requestTimeoutSecs": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### Output

Results land in the run's default dataset as one record per Facebook page. You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**, or query it via the Apify API.

#### Example output (sample item)

```json
{
  "facebookUrl": "https://www.facebook.com/copperkettleyqr",
  "pageUrl": "https://www.facebook.com/copperkettleyqr",
  "pageName": "copperkettleyqr",
  "title": "Copper Kettle",
  "categories": ["Restaurant"],
  "intro": "Tea room and gift shop in Regina serving locally sourced food.",
  "likes": 1948,
  "followers": 2041,
  "messenger": "https://m.me/copperkettleyqr",
  "address": "1953 Scarth St, Regina, SK, S4P 2H1, Canada",
  "phone": "+1-306-525-3545",
  "website": "www.copperkettle.ca",
  "email": "hello@copperkettle.ca",
  "rating": "94% recommend (238 Reviews)",
  "ratingOverall": 94,
  "ratingCount": 238,
  "creation_date": "March 15, 2014",
  "ad_status": "This Page is currently running ads.",
  "pageId": "100075002413577",
  "facebookId": "100075002413577",
  "pageAdLibrary": { "is_business_page_active": true, "id": "1234567890123456" },
  "openingHours": [],
  "hoursStatus": { "status": "closed" },
  "services": ["Dine-in", "Takeout", "Catering", "Gift Cards"],
  "extractedAt": "2026-05-16T12:00:00.000Z",
  "actorVersion": "0.3.0"
}
```

> **Schema note (v0.3.0):** the live "Open now" / "Closed now" status moved from `openingHours[0].day === "current"` to a dedicated `hoursStatus` field. Per-day grids stay in `openingHours` when JSON-LD provides them (rare for real Facebook pages, which lazy-load the grid).

### Tips and advanced options

- **Keep concurrency low.** Facebook IP-rate-limits per residential session — going from `2` to `5` parallel pages doesn't 2.5× throughput; it just adds re-tries. The default `2` is the sweet spot.
- **Use bare page slugs.** `humansofnewyork` is rewritten to `https://www.facebook.com/humansofnewyork?locale=en_US` automatically. Useful when feeding the actor from a CSV column of slugs.
- **Profile pages return fewer fields.** Personal profiles (vs. business Pages) are publicly scrapable but expose less metadata. The actor returns whatever Facebook surfaces — missing fields are omitted, not nulled.
- **Force the language.** The actor automatically appends `?locale=en_US` so extraction works the same regardless of the proxy IP's geo. Do not strip it from input URLs.
- **`followers` is sometimes missing.** Facebook renders the followers count from one of several IntroCard variants depending on the proxy session, so the value occasionally drops out of an otherwise-successful scrape. `likes` is always populated when present; consumers that need a stable audience-size signal should prefer `likes`.

### FAQ

**Is it legal to scrape Facebook?**
Public Facebook page data is generally permitted for non-personal use, but you should consult your own legal team and Facebook's Terms of Service. This actor only accesses pages reachable without login. Do not use the output to harvest personal data.

**What's the difference between a Page and a Profile?**
Pages are public-facing accounts for businesses, organizations, and public figures. Profiles are personal accounts. Pages expose more metadata; profiles expose only basic identifying fields.

**Why are residential proxies recommended?**
Facebook blocks datacenter IPs within a few requests. Residential proxies are bundled into Apify's Starter plan ($29/mo) and above.

**My run returned no data — what happened?**
Check the run log. The most common cause is a Facebook block wall or login redirect — the actor detects these and retries up to 3 times with fresh sessions before giving up on a page. If you see repeated "block/login wall" warnings, lower concurrency or upgrade to a plan with more residential proxy capacity.

### Support

Found a bug or missing field? Open an issue on the actor's **Issues** tab — we triage all reports.

# Actor input Schema

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

List of Facebook Page URLs to scrape. Provide one URL per item. Bare page slugs (e.g. "humansofnewyork") are also accepted and rewritten to https://www.facebook.com/humansofnewyork. Personal profiles work but return fewer fields than Pages.

## `maxConcurrency` (type: `integer`):

Number of Facebook pages loaded in parallel. Facebook rate-limits aggressively — keep this low (2 is the recommended default). Higher values increase the risk of session blocks and re-tries.

## `requestTimeoutSecs` (type: `integer`):

Max seconds spent loading and extracting a single Facebook page before Crawlee retries with a fresh session. Increase to 90+ for slow proxies.

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

Apify proxy settings. Residential proxies are strongly recommended — Facebook blocks datacenter IPs within a few requests. The default selects the RESIDENTIAL group when available.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork"
    },
    {
      "url": "https://www.facebook.com/nasaearth"
    }
  ],
  "maxConcurrency": 2,
  "requestTimeoutSecs": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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/humansofnewyork"
        },
        {
            "url": "https://www.facebook.com/nasaearth"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [
        { "url": "https://www.facebook.com/humansofnewyork" },
        { "url": "https://www.facebook.com/nasaearth" },
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork"
    },
    {
      "url": "https://www.facebook.com/nasaearth"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call prodiger/facebook-pages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Pages Scraper",
        "description": "Drop-in compatible Facebook Pages Scraper, ~37% cheaper than the upstream. Extracts title, intro, address, phone, website, messenger, likes, followers, rating, ad status, opening hours, and services. Adds extractedAt provenance and forced en_US locale.",
        "version": "0.3",
        "x-build-id": "el26uBuDnkmKutat5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prodiger~facebook-pages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prodiger-facebook-pages-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/prodiger~facebook-pages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-prodiger-facebook-pages-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/prodiger~facebook-pages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-prodiger-facebook-pages-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Facebook Page URLs",
                        "type": "array",
                        "description": "List of Facebook Page URLs to scrape. Provide one URL per item. Bare page slugs (e.g. \"humansofnewyork\") are also accepted and rewritten to https://www.facebook.com/humansofnewyork. Personal profiles work but return fewer fields than Pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxConcurrency": {
                        "title": "Concurrent page loads",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of Facebook pages loaded in parallel. Facebook rate-limits aggressively — keep this low (2 is the recommended default). Higher values increase the risk of session blocks and re-tries.",
                        "default": 2
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 15,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Max seconds spent loading and extracting a single Facebook page before Crawlee retries with a fresh session. Increase to 90+ for slow proxies.",
                        "default": 60
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential proxies are strongly recommended — Facebook blocks datacenter IPs within a few requests. The default selects the RESIDENTIAL group when available.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
