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

Extract business data from Facebook pages using the Facebook Pages Scraper. Collect page names, descriptions, categories, follower counts, emails, websites, and phone numbers automatically. Ideal for lead generation, market research, and local business discovery.

- **URL**: https://apify.com/scrapapi/facebook-pages-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 3 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 Pages Scraper

Facebook Pages Scraper is a fast, reliable Facebook page data extractor that turns public Facebook business pages into structured data for analysis and automation. It solves the challenge of accessing contact details, ratings, audience metrics, and links at scale — without logins or brittle browser automation. Built for marketers, developers, analysts, and researchers, this Facebook pages scraper tool powers lead generation, market research, and “scrape Facebook page to spreadsheet” workflows with clean, structured outputs.

### What data / output can you get?

Below are example fields the actor outputs to the Apify dataset (ready to export as JSON, CSV, or Excel):

| Data type | Description | Example value |
| --- | --- | --- |
| facebookUrl | Canonical URL of the scraped page | https://www.facebook.com/copperkettleyqr |
| title | Page title as shown on Facebook | The Copper Kettle Restaurant |
| pageId | Unique Facebook identifier | 100064027242849 |
| categories | Array of page categories | ["Pizza place"] |
| likes | Parsed likes count from page metadata | 2661 |
| followers | Followers count (normalized to integer when possible) | 2900 |
| email | Public email found in the “Intro”/About tiles | copperkettle.events@gmail.com |
| phone | Public phone number detected on the page | +1 306-525-3545 |
| website | Primary website domain (normalized) | thecopperkettle.online |
| websites | Array of discovered external links (site, Maps, Instagram) | ["https://thecopperkettle.online", "https://www.instagram.com/copperkettle"] |
| intro | Short description/bio extracted from the page | Longstanding local restaurant... |
| address | Address text from page context or metadata | 1953 Scarth St, Regina, Saskatchewan |
| profilePictureUrl | URL of the page profile image | https://scontent-.../n.jpg |
| coverPhotoUrl | URL of the page cover image | https://scontent-.../n.jpg |

Bonus fields included when present:
- pageName, pageUrl, category (single, derived from categories), addressUrl (maps link), profilePhoto (constructed FB photo URL), rating, ratingOverall, ratingCount, ratings, priceRange, business_price, business_services, business_hours, instagram (array of { username, url }), alternativeSocialMedia, info (parsed OG description bits), followings, creation_date, ad_status, about_me, facebookId, pageAdLibrary (is_business_page_active, id), success, error (for failed items).

### Key features

- 🔐 Advanced proxy fallback & resilience  
  Automatically escalates from direct connection → datacenter proxy → residential proxy with up to 3 retries when blocked. Keeps your automated Facebook page scraper running smoothly at scale.

- 🧾 Clean, structured output fields  
  Extracts core business signals like title, pageId, categories, likes, followers, email, phone, website(s), intro, address, images, ratings, and more — ideal for a Facebook business page scraper used in lead gen and research.

- 🌐 URL and social link detection  
  Decodes Facebook redirect links, normalizes website domains, detects Google Maps links, and captures Instagram profiles into a structured “instagram” array.

- 📈 Bulk-friendly input (URLs or usernames)  
  Paste Facebook page URLs or usernames in bulk; the actor normalizes tokens like “pagename” to full URLs. Perfect for automated Facebook page scraper runs and FB pages scraper pipelines.

- 💾 Easy exports & integrations  
  Results land in the Apify dataset — export to JSON, CSV, or Excel, or connect via API to your BI stack for “scrape Facebook page to spreadsheet” workflows.

- 🧪 No login required  
  Designed for Facebook public pages data scraping. It reads public-facing page sections without cookies or browser extensions.

- 👨‍💻 Developer-ready (Python-based actor)  
  Built on Apify’s Python stack with production-grade logging and datasets; ideal if you orchestrate via Apify API or integrate with scripts (e.g., a Facebook page scraper Python workflow).

- 🛡️ Production reliability  
  Robust error handling, retries, and proxy management so your Facebook page content extractor stays accurate and stable across runs.

### How to use Facebook Pages Scraper - step by step

1. Sign in to Apify  
   Create or log into your Apify account.

2. Open Facebook Pages Scraper  
   Find “Facebook Pages Scraper” in the Apify Store and click Try.

3. Add input data  
   In “Facebook Page URLs or Usernames”, paste one item per line. You can use full URLs (https://www.facebook.com/pagename) or just usernames (pagename).

4. Configure proxy (optional but recommended)  
   In “Proxy Configuration”, you can keep the default direct connection or enable Apify Proxy. If Facebook blocks you, the actor automatically falls back to datacenter and then residential proxies.

5. Start the run  
   Click Start. The actor fetches public page HTML, parses structured JSON blocks, and extracts contact details, audience metrics, ratings, and media URLs.

6. Monitor progress  
   Watch logs for proxy fallback events, per-page status, and success/failure counts.

7. Download results  
   Open the dataset tab and export as JSON, CSV, or Excel. Use the Apify API if you want to plug it into dashboards or pipelines.

Pro Tip: For content-level analytics (e.g., exporting page posts to CSV), pair this with a dedicated Facebook page posts scraper or Facebook page comments scraper in a downstream workflow.

### Use cases

| Use case name | Description |
| --- | --- |
| Lead generation from business pages | Capture emails, phones, websites, and Instagram links with a Facebook business page scraper to scale outreach and enrichment. |
| Market research & competitor tracking | Benchmark likes/followers, ratings, and categories with a Facebook page data extractor for ongoing competitor intelligence. |
| Local business discovery | Build geo-targeted lists from public pages, extracting addresses and maps links for territory planning. |
| Social media analytics | Track follower growth and engagement indicators by exporting structured fields to a spreadsheet or BI tool. |
| Data enrichment pipelines (API) | Feed normalized page fields to CRMs, CDPs, or internal databases using the Apify API for automated updates. |
| Academic & trend research | Collect public Facebook page metadata at scale for longitudinal studies and topic modeling. |
| Automated reporting | Run a scheduled FB pages scraper that exports to CSV/JSON and updates dashboards automatically. |

### Why choose Facebook Pages Scraper?

This tool prioritizes precision, automation, and reliability over fragile, manual scraping approaches.

- 🎯 Accurate, structured outputs — Fielded data (emails, phones, websites, ratings, media links) ready for analysis.
- 🌍 Works at scale — Paste large lists of page URLs or usernames and process them in batches.
- 👨‍💻 Developer access — Integrate via Apify datasets and API for end-to-end automation.
- 🔒 No browser extensions — More stable than a Facebook page scraper Chrome extension; no local setup required.
- 🧩 Flexible exports — Export to JSON/CSV/Excel or connect to your pipelines for “export Facebook page posts to CSV”–style reporting when combined with post scrapers.
- 🛡️ Ethical & public-only — Targets publicly available page data; no logins or private sections.
- ⚙️ Robust infrastructure — Proxy fallback logic and retries keep runs resilient in production.

In short, it’s a production-ready Facebook pages scraper tool built for clean data, dependable scaling, and automation-first workflows.

### Is it legal / ethical to use Facebook Pages Scraper?

Yes — when used responsibly. This actor targets publicly available Facebook page data and does not access private content or require authentication.

Guidelines for compliant use:
- Scrape only public page information and metadata.
- Do not collect or store private or sensitive personal data.
- Respect platform terms and applicable regulations (e.g., GDPR/CCPA).
- Use datasets for legitimate purposes (analysis, research, enrichment), not spam.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "https://www.facebook.com/copperkettleyqr",
    "ChrisBrecheensWritingAboutWriting"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array (string list) | Yes | None | List of Facebook page URLs (e.g., https://www.facebook.com/pagename) or usernames (e.g., pagename). Supports bulk input — one URL/username per line. |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Configure proxy settings. If blocked, the actor automatically falls back to datacenter proxy, then residential proxy with up to 3 retries. |

#### Example JSON output

```json
[
  {
    "facebookUrl": "https://www.facebook.com/copperkettleyqr",
    "categories": ["Pizza place"],
    "info": [
      "The Copper Kettle Restaurant, Regina. 2,661 likes",
      "23 talking about this · 1,120 were here."
    ],
    "likes": 2661,
    "messenger": null,
    "priceRange": "$$",
    "title": "The Copper Kettle Restaurant",
    "address": "1953 Scarth St, Regina, Saskatchewan",
    "pageId": "100064027242849",
    "pageName": "copperkettleyqr",
    "pageUrl": "https://www.facebook.com/copperkettleyqr",
    "intro": "Longstanding local restaurant. Mediterranean specialties, signature gourmet pizzas.",
    "websites": [
      "https://thecopperkettle.online",
      "https://www.instagram.com/copperkettle"
    ],
    "phone": "+1 306-525-3545",
    "email": "copperkettle.events@gmail.com",
    "alternativeSocialMedia": "https://www.instagram.com/copperkettle",
    "website": "thecopperkettle.online",
    "services": "Dine-in · Takeaway · Delivery",
    "rating": "94% recommend (202 Reviews)",
    "followers": 2900,
    "followings": 120,
    "profilePictureUrl": "https://scontent-.../n.jpg",
    "coverPhotoUrl": "https://scontent-.../n.jpg",
    "profilePhoto": "https://www.facebook.com/photo/?fbid=436705561807015",
    "ratingOverall": 94,
    "ratingCount": 202,
    "category": "Pizza place",
    "addressUrl": "https://www.bing.com/maps/default.aspx?v=2&pc=FACEBK&mid=8100&where1=1953+Scarth+St%2C%20Regina%2C%20Saskatchewan&FORM=FBKPL1&mkt=en-US",
    "instagram": [
      {
        "username": "copperkettle",
        "url": "https://www.instagram.com/copperkettle"
      }
    ],
    "ratings": "94% recommend (202 Reviews)",
    "business_hours": "Open now",
    "business_price": "Price Range · $$",
    "business_services": "Dine-in · Takeaway · Delivery",
    "creation_date": "August 12, 2012",
    "ad_status": null,
    "about_me": {
      "text": "Longstanding local restaurant. Mediterranean specialties, signature gourmet pizzas."
    },
    "facebookId": "100064027242849",
    "pageAdLibrary": {
      "is_business_page_active": false,
      "id": "851606664870954"
    },
    "success": true
  }
]
```

Note: On failures, the actor outputs an object with facebookUrl, error, and success=false.

### FAQ

#### Do I need to log in or provide an API token?

No. The actor targets publicly available Facebook page data and does not require login, cookies, or an API token.

#### Can I input usernames instead of full URLs?

Yes. You can paste usernames like “pagename” and the actor will normalize them into full Facebook URLs automatically.

#### Will it scrape posts, comments, or reviews text?

This actor focuses on page-level data (contact info, followers/likes, ratings summary, media URLs). To export Facebook page posts to CSV or capture comments/reviews content, pair it with a dedicated Facebook page posts scraper or Facebook page comments scraper.

#### How does proxy handling work?

If Facebook blocks a request, the actor automatically falls back from direct connection to datacenter proxy, and then to residential proxy with up to 3 retries. This keeps your automated Facebook page scraper resilient.

#### What export formats are supported?

You can export from the Apify dataset in JSON, CSV, or Excel formats, or pull data via the Apify API for your pipelines and dashboards.

#### Which data points can I expect for most pages?

Common fields include facebookUrl, title, pageId, categories, likes, followers, email, phone, website(s), intro, address, profilePictureUrl, coverPhotoUrl, and rating fields when available. Availability varies by page.

#### Is this suitable for large batches?

Yes. Paste many URLs/usernames to run bulk collections. Through Apify’s infrastructure and proxy fallback, it scales as your plan/resources allow.

#### Is it better than a browser extension?

For reliability and scale, yes. Unlike a Facebook page scraper Chrome extension, this cloud actor avoids local browser issues and includes structured outputs, retries, and proxy rotation.

### Final thoughts

Facebook Pages Scraper is built to turn public Facebook pages into clean, structured business data at scale. With robust proxy fallback, bulk input support, and export-ready outputs, it’s ideal for marketers, developers, analysts, and researchers. Connect it to the Apify API for automation, or export to CSV/JSON/Excel for rapid analysis. Start extracting smarter with a reliable FB pages scraper that’s ready for production workflows.

# Actor input Schema

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

List of Facebook page URLs (e.g., https://www.facebook.com/pagename) or usernames (e.g., pagename). Supports bulk input - one URL/username per line.

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

Configure proxy settings. By default, no proxy is used. If Facebook blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/copperkettleyqr",
    "https://www.facebook.com/ChrisBrecheensWritingAboutWriting"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

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

## JavaScript example

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

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

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

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/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": [
        "https://www.facebook.com/copperkettleyqr",
        "https://www.facebook.com/ChrisBrecheensWritingAboutWriting",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/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": [
    "https://www.facebook.com/copperkettleyqr",
    "https://www.facebook.com/ChrisBrecheensWritingAboutWriting"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/facebook-pages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Pages Scraper",
        "description": "Extract business data from Facebook pages using the Facebook Pages Scraper. Collect page names, descriptions, categories, follower counts, emails, websites, and phone numbers automatically. Ideal for lead generation, market research, and local business discovery.",
        "version": "1.0",
        "x-build-id": "RIqJEmI7mcAfDh6W5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~facebook-pages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~facebook-pages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~facebook-pages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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 or Usernames",
                        "type": "array",
                        "description": "List of Facebook page URLs (e.g., https://www.facebook.com/pagename) or usernames (e.g., pagename). Supports bulk input - one URL/username per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings. By default, no proxy is used. If Facebook blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
