# Facebook Search Scraper (`scraper-engine/facebook-search-scraper`) Actor

🔍 Collect public data from Facebook search results based on your keywords. This Apify actor extracts page names, posts, links, and basic engagement data. Useful for research, trend tracking, and competitor analysis with clean, structured output ready to export.

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

## Pricing

from $4.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Facebook Search Scraper

The Facebook Search Scraper is a purpose-built Facebook search scraper tool that discovers and extracts public business page data by combining your categories and locations, then parsing Facebook search results discovered via Google SERP. It solves the problem of manual Facebook search by automating discovery and scraping into clean, structured datasets for marketers, developers, data analysts, and researchers. As a Facebook search results scraper and Facebook public data scraper, it streamlines lead generation, trend tracking, and competitor analysis — enabling scalable Facebook search automation for your workflows. 🚀

### What data / output can you get?

Below are examples of real fields this Facebook data scraper produces for each Facebook Page found. Values may be null when unavailable on the public page.

| Data type | Description | Example value |
| --- | --- | --- |
| facebookUrl | Canonical Facebook Page URL | https://www.facebook.com/acmebrewery |
| title | Page title/name | Acme Brewery |
| categories | Category list from page metadata | ["Brewery", "Bar"] |
| category | Primary category (single value) | Brewery |
| address | Text address extracted from page | 123 Main St, New York, NY |
| phone | Public phone number | +1 212-555-0123 |
| email | Public email if listed | hello@acmebrewery.com |
| website | Website domain | acmebrewery.com |
| websites | Website URLs (normalized) | ["https://acmebrewery.com"] |
| rating | Human-readable rating summary | 95% recommend (120 Reviews) |
| ratingOverall | Numeric rating/percentage if available | 95 |
| ratingCount | Number of ratings/reviews | 120 |
| followers | Followers count (normalized to integer) | 2300 |
| followings | “Following” count if present | 150 |
| profilePictureUrl | Profile picture URI from page data | https://scontent.../profile_pic.jpg |
| coverPhotoUrl | Cover photo URL from page data | https://scontent.../cover_photo.jpg |
| profilePhoto | Deep link to profile photo by FBID | https://www.facebook.com/photo/?fbid=123456789012345 |
| pageId | Facebook Page ID | 123456789012345 |
| pageName | Vanity slug | acmebrewery |
| pageUrl | Redundant alias for facebookUrl | https://www.facebook.com/acmebrewery |
| instagram | Detected Instagram handle(s) | [{"username":"acmebrewery","url":"https://www.instagram.com/acmebrewery"}] |
| business_hours | Business hours text if available | Open now |
| priceRange | Normalized price range | $$ |
| business_price | Price range with label | Price Range · $$ |
| services | Services text if present | Delivery · Takeout |
| business_services | Services text (normalized) | Delivery · Takeout |
| addressUrl | Map deep link built from address | https://www.bing.com/maps/...where1=123%20Main%20St%2C%20New%20York%2C%20NY |
| likes | Parsed “likes” count if available | 5400 |
| info | Additional page info parsed from meta | ["5.4K likes","Brewery"] |
| about_me | About text container | {"text":"Craft beer brewed in NYC."} |
| creation_date | Formatted page creation date if known | January 15, 2018 |
| ad_status | Ads status text if detected | This Page is currently running ads. |
| pageAdLibrary | Business page ad library hints | {"is_business_page_active": true, "id": "987654321"} |
| alternativeSocialMedia | Alternate social link if detected | https://www.instagram.com/acmebrewery |
| messenger | Placeholder (not populated) | null |
| ratings | Alias of rating text | 95% recommend (120 Reviews) |
| facebookId | Alias of pageId | 123456789012345 |

Notes:
- Results are pushed live to the Apify dataset during the run. You can export results as JSON or CSV from the Apify Console.
- Bonus outputs include media links (profile and cover photos), ad status hints, map links, and Instagram handles when available.

### Key features

- 🔎 Google SERP discovery for Facebook Pages  
  Uses “site:facebook.com” queries with the Apify GOOGLE_SERP proxy to find high-quality Facebook page URLs from your category × location keywords.

- 🧭 Smart URL filtering & deduplication  
  Normalizes Facebook URLs and skips photos, videos, groups, and other non-page paths to focus on business pages.

- 🌐 Proxy fallback for reliability  
  Page scraping automatically falls back across No proxy → Datacenter → Residential when blocks are detected, improving completion rates for tough pages.

- ⚡ Parallel scraping with live saves  
  Processes multiple pages concurrently and pushes each item to the dataset in real time for faster feedback loops.

- 🧱 Structured Facebook profile scraper output  
  Clean, normalized fields like title, address, phone, email, website, rating, followers, images, Instagram handle, and more.

- 👩‍💻 Developer-friendly Apify actor  
  Built with the Apify Python SDK and aiohttp — ideal for programmatic runs and downstream pipelines that treat it as a Facebook search extractor.

- ✅ No login required  
  Works without cookies or authentication, targeting public Facebook page data only.

- 🧰 Production-ready infrastructure  
  Uses Apify Proxy, robust error handling, and retry logic for resilient scraping across categories and geographies.

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

1. Sign in to your Apify account and open the Apify Console.
2. Go to Actors and find “facebook-search-scraper”.
3. In the Input, enter:
   - categories: a list of business types (e.g., Pub, Bar, Restaurant)
   - locations: a list of places (e.g., NYC, London)
   - resultsLimit: how many pages to scrape in total (1–500)
   - proxyConfiguration: optional proxy settings for page scraping
4. Start the run. The scraper will:
   - Build queries by combining each category with each location.
   - Use the GOOGLE_SERP proxy to discover Facebook page URLs.
   - Visit each Facebook Page URL and extract structured fields.
5. Monitor the logs to see discovery and scraping progress as items are pushed.
6. When complete, open the OUTPUT tab (Dataset) and export your results as JSON or CSV.

Pro tip: Ensure your Apify account has access to the GOOGLE_SERP proxy group; discovery relies on it. If you don’t have access, discovery may return 0 URLs.

### Use cases

| Use case | Description |
| --- | --- |
| Local business lead generation | Build targeted prospect lists by scraping Facebook Pages for contact info (phone, email, website) across categories and cities. |
| Competitor tracking for brands | Monitor category peers’ public profile data, ratings, and followers to benchmark position in local markets. |
| Market research & trend analysis | Aggregate structured page signals across locations to analyze growth, engagement, and category distribution. |
| Agency account onboarding | Quickly enrich client lists with verified Facebook Page URLs, contact details, and metadata. |
| Data enrichment pipelines | Feed structured Facebook profile scraper output into BI tools and CRMs via Apify datasets. |
| Academic & policy research | Collect public business page data for urban studies, economic mapping, and social media presence analysis. |
| Territory planning | Map addresses and categories to assess coverage and potential in target geographies. |

### Why choose Facebook Search Scraper?

This Facebook search scraping software is built for precision discovery, structured extraction, and reliable operation at scale.

- 🎯 Accurate discovery via Google SERP filtering to focus on real Pages, not media or groups.
- 🧩 Structured, analysis-ready fields for contact info, ratings, followers, and media.
- 🚀 Parallelized scraping with live dataset writes to accelerate iteration.
- 🌐 Robust proxy fallback strategy that adapts to blocking and keeps jobs moving.
- 👩‍💻 Built on the Apify SDK for developers who need automation-ready Facebook search extractor workflows.
- 🔒 Public data only with no login required, aligning with responsible scraping practices.
- 💸 Efficient at scale — tune resultsLimit (up to 500) to control run time and cost.

In short: a production-grade Facebook search automation tool that outperforms brittle browser extensions and ad‑hoc scripts.

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

Yes — when used responsibly. This actor targets publicly available Facebook Page data and does not access private profiles or authenticated content.

Guidelines:
- Only collect and use public information.
- Respect platform terms and applicable laws (e.g., GDPR, CCPA).
- Avoid scraping personal/private data.
- Validate your specific use case with your legal team when in doubt.

### Input parameters & output format

#### Example input
```json
{
  "categories": ["Pub", "Bar"],
  "locations": ["NYC", "London"],
  "resultsLimit": 20,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

Parameters:

- categories (array)
  - Description: Business types to search (Pub, Bar, Restaurant...). Combined with locations → e.g. "Pub NYC", "Bar London".
  - Default: \["Pub"]
  - Required: No
- locations (array)
  - Description: Where to search (NYC, London…) — paired with each category.
  - Default: \["NYC"]
  - Required: No
- resultsLimit (integer)
  - Description: Max pages to scrape across all queries. Higher = more data, longer run.
  - Default: 10 (min: 1, max: 500)
  - Required: No
- proxyConfiguration (object)
  - Description: Optional. No proxy by default. Auto fallback to datacenter → residential if blocked.
  - Default: not set (prefill: {"useApifyProxy": false})
  - Required: No

#### Example output

```json
{
  "facebookUrl": "https://www.facebook.com/acmebrewery",
  "categories": ["Brewery", "Bar"],
  "info": ["5.4K likes", "Brewery"],
  "likes": 5400,
  "messenger": null,
  "priceRange": "$$",
  "title": "Acme Brewery",
  "address": "123 Main St, New York, NY",
  "pageId": "123456789012345",
  "pageName": "acmebrewery",
  "pageUrl": "https://www.facebook.com/acmebrewery",
  "intro": "Craft beer brewed in NYC.",
  "websites": ["https://acmebrewery.com"],
  "phone": "+1 212-555-0123",
  "email": "hello@acmebrewery.com",
  "alternativeSocialMedia": "https://www.instagram.com/acmebrewery",
  "website": "acmebrewery.com",
  "services": "Delivery · Takeout",
  "rating": "95% recommend (120 Reviews)",
  "followers": 2300,
  "followings": 150,
  "profilePictureUrl": "https://scontent.xx.fbcdn.net/v/t1.6435-1/...",
  "coverPhotoUrl": "https://scontent.xx.fbcdn.net/v/t39.30808-6/...",
  "profilePhoto": "https://www.facebook.com/photo/?fbid=123456789012345",
  "ratingOverall": 95,
  "ratingCount": 120,
  "category": "Brewery",
  "addressUrl": "https://www.bing.com/maps/default.aspx?v=2&pc=FACEBK&mid=8100&where1=123%20Main%20St%2C%20New%20York%2C%20NY&FORM=FBKPL1&mkt=en-US",
  "instagram": [
    { "username": "acmebrewery", "url": "https://www.instagram.com/acmebrewery" }
  ],
  "ratings": "95% recommend (120 Reviews)",
  "business_hours": "Open now",
  "business_price": "Price Range · $$",
  "business_services": "Delivery · Takeout",
  "creation_date": "January 15, 2018",
  "ad_status": "This Page is currently running ads.",
  "about_me": { "text": "Craft beer brewed in NYC." },
  "facebookId": "123456789012345",
  "pageAdLibrary": {
    "is_business_page_active": true,
    "id": "987654321"
  }
}
```

Notes:

- On failure, items include an "error" field alongside "facebookUrl".
- Some fields may be null or omitted if not present on the public page.

### FAQ

#### Do I need a Facebook login or cookies?

No. The scraper targets public Facebook Pages and works without login or cookies. It fetches page HTML and extracts public fields like title, contact info, ratings, and followers.

#### Is the GOOGLE\_SERP proxy required?

Yes for discovery. The actor uses the Apify GOOGLE\_SERP proxy group to find Facebook page URLs via Google search. If your account lacks access, discovery may return 0 results.

#### What exactly does it scrape — profiles, groups, or posts?

It focuses on public Facebook Pages. Discovery and filters explicitly skip non-page paths such as photos, videos, events, and groups to keep results high-quality for business pages.

#### How many pages can I scrape per run?

You control this with resultsLimit (minimum 1, maximum 500 as defined in the input schema). The actor builds queries from categories × locations and scrapes up to that limit.

#### What output fields are included?

Key fields include facebookUrl, title, categories, address, phone, email, website, rating, followers, and profilePictureUrl, plus many more like pageId, priceRange, Instagram handle, and media URLs. See the output section for a full example.

#### How are results delivered and how can I export them?

Results are pushed to the Apify dataset in real time during the run. You can download the data from the OUTPUT tab as JSON or CSV.

#### Does it handle blocking or rate limits?

Yes. For page scraping, the actor automatically falls back across No proxy → Datacenter → Residential when blocking is detected, with controlled parallelism and retries.

#### Can developers integrate this into pipelines?

Yes. It’s an Apify Actor that uses the Apify Python SDK under the hood and outputs structured JSON, making it straightforward to plug into automation and data pipelines.

### Closing CTA / Final thoughts

The Facebook Search Scraper is built to discover and extract structured Facebook Page data at scale. By combining Google SERP discovery with resilient page scraping and clean output, it delivers contact info, ratings, followers, and media for efficient research and lead workflows.

Whether you’re a marketer, analyst, or developer, you’ll get fast, structured results you can export to JSON/CSV and feed into your systems. Run it in Apify, tune resultsLimit up to 500, and use proxy fallback for reliable coverage. Start extracting smarter Facebook insights with automation-ready, structured output today.

# Actor input Schema

## `categories` (type: `array`):

Business types to search (Pub, Bar, Restaurant...). Combined with locations → e.g. "Pub NYC", "Bar London".

## `locations` (type: `array`):

Where to search (NYC, London...) — paired with each category.

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

Max pages to scrape across all queries. Higher = more data, longer run.

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

Optional. No proxy by default. Auto fallback to datacenter → residential if blocked.

## Actor input object example

```json
{
  "categories": [
    "Pub"
  ],
  "locations": [
    "NYC"
  ],
  "resultsLimit": 10,
  "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 = {
    "categories": [
        "Pub"
    ],
    "locations": [
        "NYC"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/facebook-search-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 = {
    "categories": ["Pub"],
    "locations": ["NYC"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/facebook-search-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 '{
  "categories": [
    "Pub"
  ],
  "locations": [
    "NYC"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/facebook-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Search Scraper",
        "description": "🔍 Collect public data from Facebook search results based on your keywords. This Apify actor extracts page names, posts, links, and basic engagement data. Useful for research, trend tracking, and competitor analysis with clean, structured output ready to export.",
        "version": "0.1",
        "x-build-id": "lsqjPbi4yqKOAqQID"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~facebook-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-facebook-search-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/scraper-engine~facebook-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-facebook-search-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/scraper-engine~facebook-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-facebook-search-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": {
                    "categories": {
                        "title": "🏷️ Categories",
                        "type": "array",
                        "description": "Business types to search (Pub, Bar, Restaurant...). Combined with locations → e.g. \"Pub NYC\", \"Bar London\".",
                        "default": [
                            "Pub"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "📍 Locations",
                        "type": "array",
                        "description": "Where to search (NYC, London...) — paired with each category.",
                        "default": [
                            "NYC"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "📊 Results Limit",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Max pages to scrape across all queries. Higher = more data, longer run.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy",
                        "type": "object",
                        "description": "Optional. No proxy by default. Auto fallback to datacenter → residential if blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```