# Facebook Ads Library Scraper for ClaudeCode (`dexterous_seahorse/facebook-ads-library-scraper-for-claudecode`) Actor

Scrapes public ads from Meta / Facebook Ads Library from Ads Library URLs, Facebook Page URLs, or keyword/page handles.

- **URL**: https://apify.com/dexterous\_seahorse/facebook-ads-library-scraper-for-claudecode.md
- **Developed by:** [Dexter](https://apify.com/dexterous_seahorse) (community)
- **Categories:** Lead generation, Social media, AI
- **Stats:** 3 total users, 1 monthly users, 96.1% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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.

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 Ads Library Scraper for ClaudeCode

Apify Actor for ClaudeCode workflows that accepts the same core input contract as `apify/facebook-ads-scraper` and extracts public ads from Meta / Facebook Ads Library.

### Input

The actor accepts both the Apify-style `startUrls` array and a simple single-URL API payload.

#### Keyword search

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=ALL&q=zara&search_type=keyword_unordered"
    }
  ],
  "resultsLimit": 10,
  "activeStatus": "active",
  "onlyTotal": false,
  "includeAboutPage": false,
  "isDetailsPerAd": false,
  "mode": "canonical"
}
````

#### Simple URL payload

```json
{
  "url": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=ALL&q=zara&search_type=keyword_unordered",
  "maxItems": 10
}
```

#### Facebook Page scrape

```json
{
  "startUrls": [{ "url": "https://www.facebook.com/zara" }],
  "resultsLimit": 20,
  "activeStatus": "active"
}
```

#### Direct ad detail page

```json
{
  "startUrls": [{ "url": "https://www.facebook.com/ads/library/?id=1234567890" }],
  "resultsLimit": 1,
  "strictAdDetail": true
}
```

#### Count-only mode

```json
{
  "url": "betway",
  "onlyTotal": true,
  "strictOnlyTotal": true
}
```

#### Creative/media export mode

```json
{
  "url": "betway",
  "mode": "mediaOnly",
  "resultsLimit": 50,
  "dedupeByCreativeUrl": true,
  "preferPlayableMedia": true
}
```

#### Video-first mode

```json
{
  "url": "betway",
  "mode": "videoOnly",
  "resultsLimit": 50,
  "excludePreviewOnly": true
}
```

Supported `startUrls` values:

- Meta Ad Library search/detail URLs.
- Facebook Page URLs.
- Bare page handles or keywords. These are converted to Ads Library keyword searches.

Useful controls:

- `resultsLimit`, `maxItems`, or `maxAds`: maximum output ads.
- `mode`: `canonical`, `raw`, `mediaOnly`, `metadataOnly`, `videoOnly`, or `imageOnly`.
- `maxCards`: maximum cards kept per ad before creative summary selection.
- `maxPages`: maximum scroll/pagination rounds.
- `stopAfterFirstPage`: collect only the initial loaded page.
- `onlyVideos`, `onlyImages`, `onlyCards`: mechanical result filters.
- `dedupeByAdArchiveId`: enabled by default.
- `dedupeByCreativeUrl`: dedupe repeated media variants.
- `preferPlayableMedia`: prefer real video URLs over preview images.
- `excludePreviewOnly`: remove creatives where only a video preview image was found.
- `strictPageResolve`: fail if a Facebook Page URL cannot be resolved to an exact page ID.
- `strictAdDetail`: fail if a direct ad detail URL does not yield the requested `adArchiveID`.
- `strictOnlyTotal`: fail if Meta does not expose an explicit total count.
- `includeResultsInOnlyTotal`: include sample normalized ads in count-only output.

Route behavior:

- Ads Library search URLs are treated as exact search routes.
- Ads Library detail URLs are constrained to the requested `id` and do not expand into related ads.
- Facebook Page URLs are resolved to `view_all_page_id` when possible.
- If direct page resolution fails and `strictPageResolve` is false, the actor falls back to keyword search.
- When fallback results expose a dominant `pageID`, the actor retries with `view_all_page_id` and marks `routeConfidence` as `inferred` or `probable`.
- If no page ID can be inferred, the actor keeps keyword fallback results and marks `routeConfidence` as `fallback`.

`onlyTotal` output is intentionally one compact dataset item per input:

- `totalCount`: explicit Meta count when found, otherwise observed ads count.
- `observedAdsCount`: ads actually seen while collecting payloads.
- `isTotalCountExact`: whether `totalCount` came from an explicit Meta count.
- `results`: empty by default, unless `includeResultsInOnlyTotal` is enabled.

### Output

Each ad item is normalized to the target actor's shape where possible:

- `inputUrl`
- `pageInfo`
- `sourceType`, `originalInputUrl`, `routeResolution`, `routeConfidence`
- `pageID`, `pageId`, `pageName`
- `adArchiveID`, `adArchiveId`, `adId`
- `creativeSummary`, `creativeType`, `hasPlayableVideo`, `hasOnlyPreview`
- `bestVideoUrl`, `bestImageUrl`, `previewImageUrl`, `destinationUrl`
- `snapshot` with creative text, cards, images, videos, CTA, and links
- `startDate`, `endDate`, `startDateFormatted`, `endDateFormatted`
- `publisherPlatform`, `spend`, `currency`, `reachEstimate`, regulation and safety fields

`creativeSummary` selects a deterministic representative creative:

- HD video before SD video.
- Real video before preview image.
- Real image before preview image.
- Destination-bearing cards before cards without links.
- Earlier cards before later cards when scores are equal.

Meta changes Ads Library internals frequently. The scraper listens to browser network responses and recursively extracts ad objects from Relay/GraphQL payloads instead of depending on a single endpoint name.

# Actor input Schema

## `url` (type: `string`):

Optional API-compatible shortcut. Use this for a single Meta Ads Library URL, Facebook Page URL, page handle, or keyword. If startUrls is filled, startUrls takes priority.

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

Add a Meta Ad Library URL, Facebook Page URL, page handle, or search keyword. You can add multiple URLs using Bulk edit.

## `mode` (type: `string`):

canonical returns one normalized item per ad. mediaOnly returns compact creative/media fields. videoOnly and imageOnly filter and return compact media rows. metadataOnly omits heavy snapshot data. raw keeps the full normalized snapshot shape.

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

If you leave this field empty, the actor will scrape until the page stops loading more ads or the run times out.

## `maxCards` (type: `integer`):

Optional. Limits snapshot.cards before creative summary selection. Leave empty to keep all cards returned by Meta.

## `maxPages` (type: `integer`):

Optional. Limits how many scroll/pagination rounds are attempted after the first page load.

## `stopAfterFirstPage` (type: `boolean`):

If checked, the actor collects payloads from the initial page load and does not scroll for more ads.

## `onlyTotal` (type: `boolean`):

If checked, the actor saves one dataset item per input with totalCount, observedAdsCount, and count confidence fields. Sample ad rows are omitted unless Include sample ads in onlyTotal is enabled.

## `includeResultsInOnlyTotal` (type: `boolean`):

If checked, onlyTotal output includes normalized sample ads under results. By default onlyTotal is a compact count-only result.

## `includeAboutPage` (type: `boolean`):

If checked, the actor keeps any advertiser transparency/about-page metadata returned by Meta in pageInfo.

## `isDetailsPerAd` (type: `boolean`):

If checked, the actor also opens individual Ads Library detail URLs for scraped ads when possible.

## `activeStatus` (type: `string`):

Select active status for ads.

## `onlyVideos` (type: `boolean`):

Return only ads whose selected creative has a playable video URL.

## `onlyImages` (type: `boolean`):

Return only ads whose selected creative has a real image URL and no playable video URL.

## `onlyCards` (type: `boolean`):

Return only ads that contain at least one snapshot card.

## `dedupeByAdArchiveId` (type: `boolean`):

If checked, keeps one output row per adArchiveID when Meta returns repeated variants.

## `dedupeByCreativeUrl` (type: `boolean`):

If checked, keeps one output row per best video/image/preview URL.

## `preferPlayableMedia` (type: `boolean`):

If checked, creativeSummary prefers real video URLs over previews and still images.

## `excludePreviewOnly` (type: `boolean`):

If checked, removes ads where only a video preview/thumbnail was found and no playable video or real image URL was found.

## `strictPageResolve` (type: `boolean`):

If checked, Facebook Page URLs must resolve to an exact page ID. The run fails instead of silently falling back to keyword search.

## `strictAdDetail` (type: `boolean`):

If checked, direct Ads Library detail URLs must produce a result matching the requested ad archive ID.

## `strictOnlyTotal` (type: `boolean`):

If checked, onlyTotal mode fails when Meta does not expose an explicit total count and the actor would otherwise fall back to observedAdsCount.

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

Optional. Meta can block datacenter traffic; residential proxy is recommended for reliable runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=ALL&q=zara&search_type=keyword_unordered"
    }
  ],
  "mode": "canonical",
  "resultsLimit": 10,
  "stopAfterFirstPage": false,
  "onlyTotal": false,
  "includeResultsInOnlyTotal": false,
  "includeAboutPage": false,
  "isDetailsPerAd": false,
  "activeStatus": "",
  "onlyVideos": false,
  "onlyImages": false,
  "onlyCards": false,
  "dedupeByAdArchiveId": true,
  "dedupeByCreativeUrl": false,
  "preferPlayableMedia": true,
  "excludePreviewOnly": false,
  "strictPageResolve": false,
  "strictAdDetail": false,
  "strictOnlyTotal": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=ALL&q=zara&search_type=keyword_unordered"
        }
    ],
    "resultsLimit": 10
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=ALL&q=zara&search_type=keyword_unordered" }],
    "resultsLimit": 10,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=ALL&q=zara&search_type=keyword_unordered"
    }
  ],
  "resultsLimit": 10
}' |
apify call dexterous_seahorse/facebook-ads-library-scraper-for-claudecode --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Ads Library Scraper for ClaudeCode",
        "description": "Scrapes public ads from Meta / Facebook Ads Library from Ads Library URLs, Facebook Page URLs, or keyword/page handles.",
        "version": "0.1",
        "x-build-id": "OVrVdwrHGR9n5ixHi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dexterous_seahorse~facebook-ads-library-scraper-for-claudecode/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dexterous_seahorse-facebook-ads-library-scraper-for-claudecode",
                "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/dexterous_seahorse~facebook-ads-library-scraper-for-claudecode/runs": {
            "post": {
                "operationId": "runs-sync-dexterous_seahorse-facebook-ads-library-scraper-for-claudecode",
                "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/dexterous_seahorse~facebook-ads-library-scraper-for-claudecode/run-sync": {
            "post": {
                "operationId": "run-sync-dexterous_seahorse-facebook-ads-library-scraper-for-claudecode",
                "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": {
                    "url": {
                        "title": "Single URL or keyword",
                        "type": "string",
                        "description": "Optional API-compatible shortcut. Use this for a single Meta Ads Library URL, Facebook Page URL, page handle, or keyword. If startUrls is filled, startUrls takes priority."
                    },
                    "startUrls": {
                        "title": "Meta Ad Library URL or Facebook Page URL",
                        "type": "array",
                        "description": "Add a Meta Ad Library URL, Facebook Page URL, page handle, or search keyword. You can add multiple URLs using Bulk edit.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "description": "Meta Ads Library URL, Facebook Page URL, page handle, or keyword to search in Meta Ads Library."
                                }
                            }
                        }
                    },
                    "mode": {
                        "title": "Output mode",
                        "enum": [
                            "canonical",
                            "raw",
                            "mediaOnly",
                            "metadataOnly",
                            "videoOnly",
                            "imageOnly"
                        ],
                        "type": "string",
                        "description": "canonical returns one normalized item per ad. mediaOnly returns compact creative/media fields. videoOnly and imageOnly filter and return compact media rows. metadataOnly omits heavy snapshot data. raw keeps the full normalized snapshot shape.",
                        "default": "canonical"
                    },
                    "resultsLimit": {
                        "title": "Maximum ads",
                        "minimum": 1,
                        "type": "integer",
                        "description": "If you leave this field empty, the actor will scrape until the page stops loading more ads or the run times out."
                    },
                    "maxCards": {
                        "title": "Maximum cards per ad",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional. Limits snapshot.cards before creative summary selection. Leave empty to keep all cards returned by Meta."
                    },
                    "maxPages": {
                        "title": "Maximum scroll pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional. Limits how many scroll/pagination rounds are attempted after the first page load."
                    },
                    "stopAfterFirstPage": {
                        "title": "Stop after first loaded page",
                        "type": "boolean",
                        "description": "If checked, the actor collects payloads from the initial page load and does not scroll for more ads.",
                        "default": false
                    },
                    "onlyTotal": {
                        "title": "I want only the total count of ads per page",
                        "type": "boolean",
                        "description": "If checked, the actor saves one dataset item per input with totalCount, observedAdsCount, and count confidence fields. Sample ad rows are omitted unless Include sample ads in onlyTotal is enabled.",
                        "default": false
                    },
                    "includeResultsInOnlyTotal": {
                        "title": "Include sample ads in onlyTotal",
                        "type": "boolean",
                        "description": "If checked, onlyTotal output includes normalized sample ads under results. By default onlyTotal is a compact count-only result.",
                        "default": false
                    },
                    "includeAboutPage": {
                        "title": "Include about page information",
                        "type": "boolean",
                        "description": "If checked, the actor keeps any advertiser transparency/about-page metadata returned by Meta in pageInfo.",
                        "default": false
                    },
                    "isDetailsPerAd": {
                        "title": "I want ad details as well",
                        "type": "boolean",
                        "description": "If checked, the actor also opens individual Ads Library detail URLs for scraped ads when possible.",
                        "default": false
                    },
                    "activeStatus": {
                        "title": "Active status (if not specified within the Meta Ad Library URL)",
                        "enum": [
                            "",
                            "active",
                            "inactive"
                        ],
                        "type": "string",
                        "description": "Select active status for ads.",
                        "default": ""
                    },
                    "onlyVideos": {
                        "title": "Only video creatives",
                        "type": "boolean",
                        "description": "Return only ads whose selected creative has a playable video URL.",
                        "default": false
                    },
                    "onlyImages": {
                        "title": "Only image creatives",
                        "type": "boolean",
                        "description": "Return only ads whose selected creative has a real image URL and no playable video URL.",
                        "default": false
                    },
                    "onlyCards": {
                        "title": "Only ads with cards",
                        "type": "boolean",
                        "description": "Return only ads that contain at least one snapshot card.",
                        "default": false
                    },
                    "dedupeByAdArchiveId": {
                        "title": "Dedupe by ad archive ID",
                        "type": "boolean",
                        "description": "If checked, keeps one output row per adArchiveID when Meta returns repeated variants.",
                        "default": true
                    },
                    "dedupeByCreativeUrl": {
                        "title": "Dedupe by creative media URL",
                        "type": "boolean",
                        "description": "If checked, keeps one output row per best video/image/preview URL.",
                        "default": false
                    },
                    "preferPlayableMedia": {
                        "title": "Prefer playable media",
                        "type": "boolean",
                        "description": "If checked, creativeSummary prefers real video URLs over previews and still images.",
                        "default": true
                    },
                    "excludePreviewOnly": {
                        "title": "Exclude preview-only creatives",
                        "type": "boolean",
                        "description": "If checked, removes ads where only a video preview/thumbnail was found and no playable video or real image URL was found.",
                        "default": false
                    },
                    "strictPageResolve": {
                        "title": "Strict Facebook Page resolution",
                        "type": "boolean",
                        "description": "If checked, Facebook Page URLs must resolve to an exact page ID. The run fails instead of silently falling back to keyword search.",
                        "default": false
                    },
                    "strictAdDetail": {
                        "title": "Strict ad detail mode",
                        "type": "boolean",
                        "description": "If checked, direct Ads Library detail URLs must produce a result matching the requested ad archive ID.",
                        "default": false
                    },
                    "strictOnlyTotal": {
                        "title": "Strict total count mode",
                        "type": "boolean",
                        "description": "If checked, onlyTotal mode fails when Meta does not expose an explicit total count and the actor would otherwise fall back to observedAdsCount.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Meta can block datacenter traffic; residential proxy is recommended for reliable runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
