# Facebook Ads Competitor Monitor & Tracker (`dataforge_labs/facebook-ad-change-intelligence`) Actor

Track competitor Facebook and Instagram ads. Detect new, stopped, reactivated, copy, creative, and landing-page changes with before/after evidence.

- **URL**: https://apify.com/dataforge\_labs/facebook-ad-change-intelligence.md
- **Developed by:** [Ula Ula](https://apify.com/dataforge_labs) (community)
- **Categories:** Social media, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 competitor checkeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Competitor Monitor & Tracker

Know when a competitor launches, stops, reactivates, or changes an ad - without
manually comparing Meta Ad Library results every day.

This Actor turns public Facebook and Instagram ad observations into a persistent
competitor monitor. It remembers the last complete observation and emits clean,
auditable change events with before-and-after evidence.

### Try the live demo in 60 seconds

1. Keep the prefilled Nike example.
2. Click **Start**.
3. Open the **Dataset** tab to inspect current ads, copy, creatives, landing
   pages, and source links.

The demo uses `all_current`, so the first run returns useful data immediately.
It is a one-time snapshot and does not modify a monitoring baseline.

```json
{
  "monitorId": "nike-demo-snapshot",
  "competitors": [
    {
      "id": "nike-us",
      "name": "Nike",
      "ad_library_url": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=US&view_all_page_id=15087023444"
    }
  ],
  "country": "US",
  "maxAdsPerCompetitor": 10,
  "outputMode": "all_current",
  "maxUpstreamChargeUsd": 0.05
}
````

### What you get

- `NEW` - a previously unseen ad ID
- `COPY_CHANGED` - ad text or call to action changed
- `CREATIVE_CHANGED` - creative URLs or creative fingerprint changed
- `LANDING_PAGE_CHANGED` - the normalized destination changed
- `REACTIVATED` - a previously stopped ad returned
- `STOPPED` - an ad disappeared from repeated complete observations or was
  explicitly observed as inactive
- Before-and-after records for audit and reporting
- Stable event IDs for deduplication in Make, Zapier, n8n, or your own system
- A run summary even on quiet days when no changes are found

### Set up daily monitoring

#### 1. Use an exact advertiser locator

Open the advertiser in Meta Ad Library and copy the filtered URL. Put that URL
in `ad_library_url`. A numeric `page_id` or Facebook `page_url` also works.

Use `search_term` only as a fallback: keyword search can include similarly named
or unrelated advertisers.

#### 2. Create the baseline

Change `outputMode` to `changes`, choose a stable `monitorId`, and start the
Actor. The first successful run creates a silent baseline. The run summary will
say that the baseline was created; an empty Dataset is expected at this stage.

For monitoring, set `maxAdsPerCompetitor` above the advertiser's likely total.
If a result exactly reaches the cap, the Actor treats it as partial and protects
the existing baseline from false stopped-ad alerts.

```json
{
  "monitorId": "client-acme-daily",
  "competitors": [
    {
      "id": "competitor-one-us",
      "name": "Competitor One",
      "ad_library_url": "PASTE_THE_EXACT_META_AD_LIBRARY_URL_HERE"
    }
  ],
  "country": "US",
  "maxAdsPerCompetitor": 250,
  "outputMode": "changes",
  "stoppedAfterMissingRuns": 2,
  "maxUpstreamChargeUsd": 1
}
```

#### 3. Save and schedule

Click **Save as a new task**, then add a daily Schedule. Keep the same
`monitorId`; that is the key connecting today's observation with future runs.

#### 4. Deliver alerts

Attach a run-succeeded webhook or integration to the saved task. The default
Dataset is your event feed. The `OUTPUT` key-value-store record is the compact
run summary for health checks and dashboards.

Useful destinations include Slack, Microsoft Teams, Make, Zapier, n8n, Google
Sheets, Airtable, a CRM, a warehouse, or your own endpoint.

### Output modes

| Mode | Best for | Baseline behavior | Dataset on first run |
| --- | --- | --- | --- |
| `all_current` | Demo, research, one-time export | Does not read or update it | Current ads |
| `changes` | Recurring monitoring | Creates or updates it safely | Empty baseline run |
| `all` | Monitoring plus initial inventory | Creates or updates it safely | Initial ads as `NEW` |

### Example change event

```json
{
  "event_id": "evt_...",
  "event_type": "COPY_CHANGED",
  "monitor_id": "client-acme-daily",
  "competitor_id": "competitor-one-us",
  "competitor_name": "Competitor One",
  "ad_id": "1234567890",
  "changed_fields": ["copy"],
  "before": {
    "ad_id": "1234567890",
    "copy": "Old promotional message",
    "landing_url": "https://example.com/offer"
  },
  "after": {
    "ad_id": "1234567890",
    "copy": "New promotional message",
    "landing_url": "https://example.com/offer"
  },
  "detected_at": "2026-07-15T12:00:00Z",
  "source_url": "https://www.facebook.com/ads/library/?id=1234567890"
}
```

The event contains both normalized evidence and a source URL when the upstream
provider exposes one. A `STOPPED` event is an observation signal, not proof that
Meta formally ended an ad.

### Reliability safeguards

Ad monitoring is only valuable when partial scrapes do not create false alerts.
This Actor therefore:

- Never updates state after a failed upstream run
- Rejects capped or explicitly partial observations for baseline updates
- Protects the baseline when observed inventory collapses below 50% of the
  previous complete snapshot
- Requires at least two complete absences before emitting `STOPPED`
- Normalizes whitespace and common tracking parameters before comparison
- Emits `REACTIVATED` once when an absent ad returns
- Produces deterministic event IDs for downstream deduplication
- Honors the user's maximum run charge before starting paid competitor checks

State is isolated in a named key-value store derived from `monitorId`. Use a
different ID for each client, market, or independent monitor.

### Inputs

Every competitor needs a stable `id` and one locator:

- `ad_library_url` - recommended exact Meta Ad Library URL with filters
- `page_id` - exact numeric Facebook page ID
- `page_url` - public Facebook page URL
- `search_term` - broad keyword fallback

Other controls:

- `country` - two-letter Meta Ad Library country code
- `maxAdsPerCompetitor` - requested records per competitor, 1-500
- `outputMode` - `all_current`, `changes`, or `all`
- `stoppedAfterMissingRuns` - complete absences required before `STOPPED`
- `maxUpstreamChargeUsd` - hard combined ceiling for child Actor calls
- `upstreamActorId` - advanced replacement for the default data provider
- `upstreamInputOverrides` - advanced provider-specific JSON

### Pricing

You pay:

- **$0.01 per Actor start**
- **$0.10 per successfully processed competitor**
- The selected upstream Meta Ad Library provider separately, within your
  `maxUpstreamChargeUsd` limit
- No additional platform-usage charge for this Actor

Examples for this Actor's event fees:

| Workload | Actor fee per run | Approx. Actor fee per 30 days |
| --- | ---: | ---: |
| 1 competitor, daily | $0.11 | $3.30 |
| 5 competitors, daily | $0.51 | $15.30 |
| 10 competitors, daily | $1.01 | $30.30 |

Upstream charges are extra and depend on returned records and the provider's
current pricing. Start with one advertiser and a small snapshot, inspect Usage,
then increase the monitoring limit. The hard upstream ceiling prevents an
unexpected child-run bill, but setting it too low can stop a child run early.

### Use from JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor(
  'dataforge_labs/facebook-ad-change-intelligence'
).call({
  monitorId: 'client-acme-daily',
  competitors: [{
    id: 'competitor-one-us',
    name: 'Competitor One',
    page_id: '1234567890',
  }],
  country: 'US',
  maxAdsPerCompetitor: 250,
  outputMode: 'changes',
  maxUpstreamChargeUsd: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use from Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor(
    "dataforge_labs/facebook-ad-change-intelligence"
).call(run_input={
    "monitorId": "client-acme-daily",
    "competitors": [{
        "id": "competitor-one-us",
        "name": "Competitor One",
        "page_id": "1234567890",
    }],
    "country": "US",
    "maxAdsPerCompetitor": 250,
    "outputMode": "changes",
    "maxUpstreamChargeUsd": 1,
})

events = client.dataset(run["defaultDatasetId"]).list_items().items
print(events)
```

### Limitations

- Meta controls public availability; results may not represent an advertiser's
  complete portfolio
- Search terms can include unrelated advertisers
- Creative URLs can be temporary or missing
- Meta and upstream providers can change fields or pagination behavior
- This Actor does not log in, bypass access controls, or use Meta's official API
- A capped snapshot can still be useful for research, but capped observations
  are not allowed to mutate a monitoring baseline

### FAQ

#### Why is my first monitoring Dataset empty?

`changes` needs two observations to detect a change. The first complete run
creates the baseline and writes a clear explanation to the run summary. Use
`all_current` for instant results or `all` to emit the baseline as `NEW` events.

#### Why was my baseline not updated?

The observation was likely failed, capped, explicitly partial, or suspiciously
smaller than the previous snapshot. This is intentional protection against
false `STOPPED` alerts. Increase `maxAdsPerCompetitor` or inspect the child run.

#### How often should I schedule it?

Daily is a practical default. Higher frequency costs more and does not guarantee
that Meta exposes updates sooner.

#### Can I monitor multiple clients?

Yes. Use a separate `monitorId` for each client or independent monitor. You can
include up to 100 competitors in one input, subject to your maximum run charge.

#### Does it download creative files?

No. It stores normalized fields, URLs, and fingerprints rather than creative
binaries.

### Start now

Run the prefilled snapshot to see the output. Then replace Nike with your exact
competitor, switch to `changes`, save the input as a Task, and schedule it daily.

# Actor input Schema

## `monitorId` (type: `string`):

Re-use the same ID on every scheduled run to preserve history.

## `competitors` (type: `array`):

Add 1-100 competitors. Each object needs a unique id plus exactly one locator: ad\_library\_url, page\_url, page\_id, or search\_term.

## `country` (type: `string`):

Two-letter Meta Ad Library country code.

## `maxAdsPerCompetitor` (type: `integer`):

Demo: 10. Monitoring: choose a limit above the advertiser's expected ad count; a run that hits the limit is treated as partial and will not overwrite the baseline.

## `outputMode` (type: `string`):

Controls whether the dataset contains today's ads or only changes against the stored baseline.

## `stoppedAfterMissingRuns` (type: `integer`):

Safety threshold: consecutive complete runs in which an ad must be absent before emitting STOPPED.

## `maxUpstreamChargeUsd` (type: `number`):

Total PPE ceiling divided across all child Actor calls.

## `upstreamActorId` (type: `string`):

Advanced: replaceable Actor used to retrieve Meta Ad Library records. Keep the default unless you have tested another supported adapter.

## `upstreamInputOverrides` (type: `object`):

Advanced: vendor-specific JSON merged over the generated upstream input.

## Actor input object example

```json
{
  "monitorId": "nike-demo-snapshot",
  "competitors": [
    {
      "id": "nike-us",
      "name": "Nike",
      "ad_library_url": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=US&view_all_page_id=15087023444"
    }
  ],
  "country": "US",
  "maxAdsPerCompetitor": 10,
  "outputMode": "all_current",
  "stoppedAfterMissingRuns": 2,
  "maxUpstreamChargeUsd": 0.05,
  "upstreamActorId": "scrapesage/facebook-ad-library-scraper",
  "upstreamInputOverrides": {}
}
```

# Actor output Schema

## `changeEvents` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "monitorId": "nike-demo-snapshot",
    "competitors": [
        {
            "id": "nike-us",
            "name": "Nike",
            "ad_library_url": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=US&view_all_page_id=15087023444"
        }
    ],
    "country": "US",
    "maxAdsPerCompetitor": 10,
    "outputMode": "all_current",
    "maxUpstreamChargeUsd": 0.05
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataforge_labs/facebook-ad-change-intelligence").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 = {
    "monitorId": "nike-demo-snapshot",
    "competitors": [{
            "id": "nike-us",
            "name": "Nike",
            "ad_library_url": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=US&view_all_page_id=15087023444",
        }],
    "country": "US",
    "maxAdsPerCompetitor": 10,
    "outputMode": "all_current",
    "maxUpstreamChargeUsd": 0.05,
}

# Run the Actor and wait for it to finish
run = client.actor("dataforge_labs/facebook-ad-change-intelligence").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 '{
  "monitorId": "nike-demo-snapshot",
  "competitors": [
    {
      "id": "nike-us",
      "name": "Nike",
      "ad_library_url": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=US&view_all_page_id=15087023444"
    }
  ],
  "country": "US",
  "maxAdsPerCompetitor": 10,
  "outputMode": "all_current",
  "maxUpstreamChargeUsd": 0.05
}' |
apify call dataforge_labs/facebook-ad-change-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Ads Competitor Monitor & Tracker",
        "description": "Track competitor Facebook and Instagram ads. Detect new, stopped, reactivated, copy, creative, and landing-page changes with before/after evidence.",
        "version": "0.1",
        "x-build-id": "f5zX6QpXiWcbbdFtY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dataforge_labs~facebook-ad-change-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dataforge_labs-facebook-ad-change-intelligence",
                "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/dataforge_labs~facebook-ad-change-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-dataforge_labs-facebook-ad-change-intelligence",
                "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/dataforge_labs~facebook-ad-change-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-dataforge_labs-facebook-ad-change-intelligence",
                "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": [
                    "monitorId",
                    "competitors"
                ],
                "properties": {
                    "monitorId": {
                        "title": "Monitor ID",
                        "pattern": "^[A-Za-z0-9_-]{1,100}$",
                        "type": "string",
                        "description": "Re-use the same ID on every scheduled run to preserve history.",
                        "default": "my-competitor-monitor"
                    },
                    "competitors": {
                        "title": "Competitors",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add 1-100 competitors. Each object needs a unique id plus exactly one locator: ad_library_url, page_url, page_id, or search_term.",
                        "items": {
                            "type": "object",
                            "required": [
                                "id"
                            ],
                            "properties": {
                                "id": {
                                    "title": "Competitor ID",
                                    "type": "string",
                                    "description": "Stable unique key used in snapshots and events."
                                },
                                "name": {
                                    "title": "Display name",
                                    "type": "string",
                                    "description": "Human-readable competitor name."
                                },
                                "page_id": {
                                    "title": "Meta page ID",
                                    "type": "string",
                                    "description": "Exact numeric Facebook page ID, for example 15087023444."
                                },
                                "page_url": {
                                    "title": "Facebook page URL",
                                    "type": "string",
                                    "description": "Public Facebook page URL."
                                },
                                "ad_library_url": {
                                    "title": "Ad Library URL",
                                    "type": "string",
                                    "description": "Recommended: full Meta Ad Library URL with country, status, and advertiser filters."
                                },
                                "search_term": {
                                    "title": "Search term",
                                    "type": "string",
                                    "description": "Broad keyword fallback. It can return unrelated advertisers with similar names."
                                }
                            }
                        },
                        "default": [
                            {
                                "id": "nike-us",
                                "name": "Nike",
                                "ad_library_url": "https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=US&view_all_page_id=15087023444"
                            }
                        ]
                    },
                    "country": {
                        "title": "Country",
                        "pattern": "^[A-Z]{2}$",
                        "type": "string",
                        "description": "Two-letter Meta Ad Library country code.",
                        "default": "US"
                    },
                    "maxAdsPerCompetitor": {
                        "title": "Maximum ads per competitor",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Demo: 10. Monitoring: choose a limit above the advertiser's expected ad count; a run that hits the limit is treated as partial and will not overwrite the baseline.",
                        "default": 100
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "changes",
                            "all",
                            "all_current"
                        ],
                        "type": "string",
                        "description": "Controls whether the dataset contains today's ads or only changes against the stored baseline.",
                        "default": "changes"
                    },
                    "stoppedAfterMissingRuns": {
                        "title": "Missing runs before STOPPED",
                        "minimum": 2,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Safety threshold: consecutive complete runs in which an ad must be absent before emitting STOPPED.",
                        "default": 2
                    },
                    "maxUpstreamChargeUsd": {
                        "title": "Maximum upstream spend per run (USD)",
                        "minimum": 0.01,
                        "maximum": 100,
                        "type": "number",
                        "description": "Total PPE ceiling divided across all child Actor calls.",
                        "default": 5
                    },
                    "upstreamActorId": {
                        "title": "Upstream Actor ID",
                        "type": "string",
                        "description": "Advanced: replaceable Actor used to retrieve Meta Ad Library records. Keep the default unless you have tested another supported adapter.",
                        "default": "scrapesage/facebook-ad-library-scraper"
                    },
                    "upstreamInputOverrides": {
                        "title": "Upstream input overrides",
                        "type": "object",
                        "description": "Advanced: vendor-specific JSON merged over the generated upstream input.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
