# Facebook Ad Library Scraper (`scrapeio/facebook-ad-library-scraper`) Actor

Scrape every Meta ad (Facebook, Instagram, Messenger, Audience Network) from the Ad Library by keyword, Facebook Page ID, or Ad Library URL. Sort by total impressions or most recent. Extract creatives, copy, CTAs, impressions, and spend ranges. 100+ languages. No Meta Graph API or developer app.

- **URL**: https://apify.com/scrapeio/facebook-ad-library-scraper.md
- **Developed by:** [Shop Intel](https://apify.com/scrapeio) (community)
- **Categories:** Lead generation, Agents, Developer tools
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Ad Library Scraper – Extract Meta Ads by Keyword, Page ID & URL | Apify Actor

**Facebook Ad Library Scraper** extracts live and historical ads from the [Meta Ad Library](https://www.facebook.com/ads/library) — search by keyword, Facebook Page ID, or custom Ad Library URL, capture creative, copy, impressions, spend ranges, and export structured data in JSON or CSV.

### 🧠 Overview

This **Facebook Ad Library Scraper** is a premium Apify Actor for performance marketers, competitive‑intelligence teams, political researchers, and agencies that need **bulk structured access to Meta ads across Facebook, Instagram, Messenger, and the Audience Network**. Input a keyword (e.g., `nike`), a Facebook Page ID, or a pre‑filtered Ad Library URL, choose `sortBy` (`total_impressions` or `most_recent`), set your `maxResults`, and the Actor scrapes every matching ad — **creative, copy, CTA, landing URLs, impressions ranges, spend ranges, regions, demographics, and run timing**. Zero filtering technology and universal language support (100+ languages including Arabic, Chinese, Japanese, Korean, Russian) keep the yield high on international brands. No Meta developer app, no token lifecycle, no API review.

### 🆚 Facebook Ad Library Scraper vs. Meta Ad Library API

| Feature | Official Meta Ad Library API | **This Facebook Ad Library Scraper** |
|---|---|---|
| **Developer app** | Required (with review) | **None** |
| **Access tokens** | Graph API token lifecycle | **None** |
| **Ad types** | Mostly political / issue ads | **All ad types** — commercial, political, issue |
| **Regions** | Limited political disclosure markets | **Global**, all Ad Library regions |
| **Languages** | English‑biased | **100+ languages** incl. Arabic, Chinese, Japanese, Korean, Russian |
| **Sort order** | Default only | **`total_impressions`** or **`most_recent`** |
| **Input modes** | Structured query only | Keyword, **Page ID**, or full **Ad Library URL** |
| **Output** | JSON only | **CSV, JSON, Excel** + key‑value store |
| **Setup time** | Days (app review) | **Seconds** |

### ✨ Features

- **Extract** every ad currently in the Meta Ad Library by keyword, Page ID, or URL.
- **Search** across Facebook, Instagram, Messenger, and Audience Network placements in one run.
- **Sort** results by `total_impressions` (high to low) or `most_recent` (relevancy, grouped by month).
- **Scrape** unlimited ads per run — no hard `maxResults` cap.
- **Capture** creative assets: ad body, title, CTA, landing page, image and video URLs.
- **Track** performance ranges: impressions lower/upper bounds and spend ranges (where disclosed).
- **Map** distribution: regions, countries, age ranges, and gender targeting.
- **Support** 100+ languages including Arabic, Chinese, Japanese, Korean, Russian — zero filtering on non‑Latin scripts.
- **Export** per‑ad Dataset rows + structured `OUTPUT` JSON with summary and ads array.
- **Automate** with the Apify scheduler, webhooks, and REST API for always‑on ad monitoring.
- **Handle** typed error objects and `summary.status` (`SUCCESS` / `ERROR`) for reliable pipelines.

### 🎯 Use Cases

- **Competitor Ad Monitoring:** Track every Meta ad a competitor is running across Facebook and Instagram — with creative, copy, and landing URLs.
- **Creative Strategy & Swipe Files:** Build a searchable library of high‑performing ads (sorted by `total_impressions`) for your creative team's briefs.
- **Political Ad Transparency:** Collect political and issue ads for journalism, academic research, and regulatory reporting.
- **Brand Safety & IP Enforcement:** Detect counterfeit brand ads, unauthorized affiliates, and trademark misuse running on Meta platforms.
- **Market Intelligence by Region:** Use custom Ad Library URLs to filter by country, date range, ad type, and platform — then benchmark spend and creative across markets.
- **Agency New Business:** Scrape a prospect's Meta ad footprint pre‑pitch to diagnose creative gaps and propose concrete campaign ideas.

### ⚙️ Input Parameters

| Name | Type | Required | Description | Example |
|------|------|----------|-------------|---------|
| `keyword` | string | One of three | Brand or search term (e.g., `nike`, `adidas`). | `"nike"` |
| `pageId` | string | One of three | Numeric Facebook Page ID. | `"15087023549"` |
| `adLibraryUrl` | string | One of three | Full Meta Ad Library URL with filters. | `"https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&q=nike"` |
| `maxResults` | integer | Yes | Target number of ads to collect (no upper limit). | `500` |
| `sortBy` | string | No | `total_impressions` (default) or `most_recent`. | `"total_impressions"` |

### 📤 Output Example (JSON)

```json
{
  "metadata": {
    "adArchiveId": "1234567890123456",
    "pageId": "15087023549",
    "pageName": "Nike",
    "publisherPlatforms": ["FACEBOOK", "INSTAGRAM"]
  },
  "ad_content": {
    "body": "Just Do It. Discover the new Pegasus 41.",
    "title": "Nike Pegasus 41",
    "cta": "Shop Now",
    "landingUrl": "https://www.nike.com/launch/t/pegasus-41",
    "mediaUrls": ["https://scontent.../video.mp4"]
  },
  "timing": {
    "startDate": "2026-03-15",
    "endDate": null,
    "active": true
  },
  "performance": {
    "impressions": { "lowerBound": 500000, "upperBound": 999999 },
    "spend": { "lowerBound": 10000, "upperBound": 14999, "currency": "USD" }
  },
  "distribution": {
    "regions": ["US", "CA", "UK", "DE"],
    "demographics": { "ageRange": "18-44", "gender": "all" }
  },
  "status": { "active": true, "adDeliveryStartTime": 1710460800 }
}
````

### 📋 Output Data Schema

Every Meta ad is returned as a structured object with these top‑level keys:

| Key | Type | Fields |
|---|---|---|
| `metadata` | object | `adArchiveId`, `pageId`, `pageName`, `publisherPlatforms` (`FACEBOOK`, `INSTAGRAM`, `MESSENGER`, `AUDIENCE_NETWORK`, `WHATSAPP`) |
| `ad_content` | object | `body`, `title`, `cta`, `landingUrl`, `mediaUrls[]` |
| `timing` | object | `startDate`, `endDate`, `active` |
| `performance` | object | `impressions.lowerBound`, `impressions.upperBound`, `spend.lowerBound`, `spend.upperBound`, `spend.currency` |
| `distribution` | object | `regions[]`, `demographics.ageRange`, `demographics.gender` |
| `status` | object | `active`, `adDeliveryStartTime`, `adDeliveryStopTime` |
| `additional_info` | object | Any extra fields Meta exposes (creative tags, disclaimers, political/issue labels) |

Run‑level `OUTPUT` also contains `summary.status` (`SUCCESS` / `ERROR`), `summary.totalAds`, `summary.keyword`, `summary.sortBy`, and timing metadata.

### ▶️ How to Use

1. **Run on Apify Console:** Open the [Facebook Ad Library Scraper page](https://apify.com/scrapeio/meta-facebook-ad-scrapper-using-ad-library-url-premium), click **Try for free**, enter a keyword (or Page ID / URL), set `maxResults` and `sortBy`, and press **Start**.
2. **Via API:** Trigger runs programmatically with the [Apify REST API](https://docs.apify.com/api/v2) or `ApifyClient` and stream the Dataset into your pipeline.
3. **Via CLI:** Run with the [Apify CLI](https://docs.apify.com/cli):
   ```bash
   apify call scrapeio/meta-facebook-ad-scrapper-using-ad-library-url-premium \
     --input='{"keyword":"nike","maxResults":200,"sortBy":"total_impressions"}'
   ```

### 🔗 API Example (JavaScript)

```js
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('scrapeio/meta-facebook-ad-scrapper-using-ad-library-url-premium').call({
  keyword: 'nike',
  maxResults: 150,
  sortBy: 'total_impressions',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Collected ${items.length} Meta ads`);
items.slice(0, 3).forEach(ad => {
  console.log(`${ad.metadata.pageName}: ${ad.ad_content.title}`);
});
```

### 📈 Why Use This Meta Ad Library Scraper?

- **Speed & Automation:** Pull hundreds of Meta ads per brand or keyword in minutes — no manual Ad Library browsing or screenshots.
- **Universal Language Support:** Zero‑filtering technology handles 100+ languages including Arabic, Chinese, Japanese, Korean, and Russian — unique among Apify ad scrapers.
- **Flexible Input Modes:** Keyword, Page ID, or full Ad Library URL — plug it into whatever workflow your analysts already use.
- **Impression‑Sorted Intelligence:** `sortBy=total_impressions` surfaces the highest‑reach ads first — the single best signal for creative strategy.
- **No Meta Developer Account:** Skip the Ad Library API approval queue, Graph API tokens, and rate‑limited SDKs — start scraping immediately.
- **Developer Integrations:** Apify REST API, webhooks, scheduler, JavaScript + Python SDKs, and structured `OUTPUT` for n8n, Make, Zapier, Google Sheets, and BigQuery.

### ❓ FAQ

**Q: Is it legal to scrape the Meta Ad Library?**
The Meta Ad Library is a public transparency product from Meta itself. Using it for research, journalism, competitive intelligence, and compliance monitoring is widely accepted. You are responsible for complying with [Meta's Terms of Service](https://www.facebook.com/terms.php) and local data laws.

**Q: How is this different from Meta's own Ad Library API?**
Meta's Ad Library API requires developer app review, Graph API tokens, and is largely limited to political and issue ads in many regions. This Actor works with all ad types in the public UI and returns structured rows without developer approval.

**Q: Does it support Instagram and WhatsApp ads?**
Yes — any ad with `INSTAGRAM` or `WHATSAPP` in `publisherPlatforms` is returned. If you only want Instagram, use the companion **Instagram Ads Scraper**; for WhatsApp only, use the **WhatsApp Ads Scraper**.

**Q: What is the difference between `total_impressions` and `most_recent`?**
`total_impressions` sorts ads from highest to lowest reach (best for creative strategy). `most_recent` matches Meta's grouped "recent" view and surfaces freshly launched ads first.

**Q: Can I filter by country or date range?**
Yes — build a custom Ad Library URL with the filters you need in the browser and paste it into `adLibraryUrl`. The Actor honors `country`, `active_status`, `ad_type`, and date parameters.

**Q: Does it support proxies?**
Yes. Configure Apify Proxy (residential or datacenter) for stable high‑volume or scheduled runs.

**Q: What output formats are supported?**
Dataset exports to CSV, JSON, Excel, XML, and HTML. `OUTPUT` JSON contains a `summary` object and a `data.ads` array for the full run context.

**Q: Does it handle CAPTCHAs and rate limits?**
Yes — the Actor retries transient errors, rotates through proxy sessions, and returns typed errors in `summary.error` for debuggable pipelines.

### 📣 Start Scraping the Meta Ad Library Today

**[Run the Facebook Ad Library Scraper on Apify now →](https://apify.com/scrapeio/meta-facebook-ad-scrapper-using-ad-library-url-premium)** and turn any brand, keyword, or Ad Library URL into a live feed of Meta ad creatives, impressions, and spend data.

***

### 🔗 Related Scrapers by ScrapeIO

Build cross‑platform ad‑intelligence pipelines with these companion Apify Actors:

- **[Instagram Ads Scraper](https://apify.com/scrapeio/instagram-scraper-premium)** — Instagram‑only ads with creative and copy.
- **[WhatsApp Ads Scraper](https://apify.com/scrapeio/whatsapp-scraper-premium)** — Click‑to‑WhatsApp ad intelligence.
- **[Facebook Ad Library Brand Finder](https://apify.com/scrapeio/facebook-ad-library-suggestions)** — resolve brand names to verified Page IDs.
- **[Google Maps Scraper](https://apify.com/scrapeio/google-maps-scraper-advance)** — local businesses, reviews, and contacts.
- **[Amazon Multi‑Marketplace Scraper](https://apify.com/scrapeio/amazon-multi-marketplace-scraper-most-advanced)** — ASINs, prices, and rankings across 23 regions.
- **[Google News Scraper](https://apify.com/scrapeio/google-news-scraper)** — headlines, sources, and publisher links by keyword.
- **[YouTube Video Downloader](https://apify.com/scrapeio/youtube-downloader)** — download videos or audio to cloud storage.

***

**[FastAd](https://www.fastad.in)** — automation & growth tooling.

# Actor input Schema

## `keyword` (type: `string`):

Optional. Search term or brand name (e.g. 'nike', 'adidas'). Use this OR pageId OR adLibraryUrl—only one needed.

## `pageId` (type: `string`):

Optional. Facebook Page ID (brand ID). Use this OR keyword OR adLibraryUrl—only one needed.

## `adLibraryUrl` (type: `string`):

Optional. Full Facebook/Meta Ad Library URL. Use this OR keyword OR pageId—only one needed.

## `maxResults` (type: `integer`):

How many ads you want. We scrape until we have this many or there are no more results. No upper limit.

## `sortBy` (type: `string`):

How Meta orders ads (matches Ad Library URL sort\_data). total\_impressions: high to low by impressions (sort\_data\[mode]=total\_impressions). most\_recent: relevancy / monthly grouped (sort\_data\[mode]=relevancy\_monthly\_grouped), like Meta’s grouped “recent” view.

## Actor input object example

```json
{
  "keyword": "nike",
  "adLibraryUrl": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&q=nike&search_type=keyword_unordered",
  "maxResults": 50,
  "sortBy": "total_impressions"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeio/facebook-ad-library-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapeio/facebook-ad-library-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 '{}' |
apify call scrapeio/facebook-ad-library-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Ad Library Scraper",
        "description": "Scrape every Meta ad (Facebook, Instagram, Messenger, Audience Network) from the Ad Library by keyword, Facebook Page ID, or Ad Library URL. Sort by total impressions or most recent. Extract creatives, copy, CTAs, impressions, and spend ranges. 100+ languages. No Meta Graph API or developer app.",
        "version": "2.2",
        "x-build-id": "u3E5Sq41MlWnXj3TY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeio~facebook-ad-library-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeio-facebook-ad-library-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/scrapeio~facebook-ad-library-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeio-facebook-ad-library-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/scrapeio~facebook-ad-library-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeio-facebook-ad-library-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": [
                    "maxResults"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword or Brand Name",
                        "type": "string",
                        "description": "Optional. Search term or brand name (e.g. 'nike', 'adidas'). Use this OR pageId OR adLibraryUrl—only one needed.",
                        "default": "nike"
                    },
                    "pageId": {
                        "title": "Brand / Page ID",
                        "type": "string",
                        "description": "Optional. Facebook Page ID (brand ID). Use this OR keyword OR adLibraryUrl—only one needed."
                    },
                    "adLibraryUrl": {
                        "title": "Ad Library URL",
                        "type": "string",
                        "description": "Optional. Full Facebook/Meta Ad Library URL. Use this OR keyword OR pageId—only one needed.",
                        "default": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&q=nike&search_type=keyword_unordered"
                    },
                    "maxResults": {
                        "title": "Number of Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many ads you want. We scrape until we have this many or there are no more results. No upper limit.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "total_impressions",
                            "most_recent"
                        ],
                        "type": "string",
                        "description": "How Meta orders ads (matches Ad Library URL sort_data). total_impressions: high to low by impressions (sort_data[mode]=total_impressions). most_recent: relevancy / monthly grouped (sort_data[mode]=relevancy_monthly_grouped), like Meta’s grouped “recent” view.",
                        "default": "total_impressions"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
