# Newsletter Sponsorship Intelligence — Substack, beehiiv & Ghost (`silentshadow55/newsletter-sponsors-actor`) Actor

Extract sponsors and ad placements from Substack, beehiiv, and Ghost newsletters. Give it newsletter URLs and get, per issue: the sponsor brand names, the marker phrase (Presented by / Together with / Sponsored by), the sponsor link, and utm\_source / utm\_campaign. Pure HTTP, no logins, no LLM.

- **URL**: https://apify.com/silentshadow55/newsletter-sponsors-actor.md
- **Developed by:** [Esteban Ortega](https://apify.com/silentshadow55) (community)
- **Categories:** Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 newsletter issues

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

## Newsletter Sponsorship Intelligence — Who Sponsors Substack, beehiiv & Ghost (Sponsor & Advertiser Extractor)

**Find out who sponsors a newsletter — any Substack, beehiiv, or Ghost newsletter you choose.** Give this actor a list of newsletter URLs and it returns, for each recent issue, the **sponsor brand names**, the **marker phrase** that flagged the ad ("Presented by", "Together with", "Sponsored by", "Brought to you by"), the **sponsor link**, and the **utm_source / utm_campaign** tracking parameters. Pure HTTP, no logins, no API keys, no LLM — just fast, deterministic parsing, with **1.000 precision and recall on the ground-truth test set** across all three platforms.

Built for ad-sales teams, competitive-intelligence analysts, media buyers, and sponsorship marketplaces who need to know **which brands are advertising in which newsletters** — and how often.

> Sponsorship analytics on newsletters *you* choose to monitor: you supply the URLs, and the actor reads only public issue pages. No inbox access, no private content.

---

### What it does

- **Auto-detects the platform** from a bare newsletter URL: Substack (including custom domains), beehiiv, or Ghost.
- **Enumerates recent issues** — Substack archive API, beehiiv `/archive` + `sitemap.xml`, Ghost `/rss/` full-content feed (Ghost depth is capped at the RSS window, ~15 newest issues).
- **Extracts sponsors with pure heuristics** — case-insensitive marker phrases anchored to standalone ad headers or sentence-initial lines, brand names repaired from the block's outbound link (destination domain, redirect-link slug, or `utm_source` as a last resort).
- **Avoids the usual false positives** — footer "sponsoring the podcast" boilerplate, `utm_source` strings buried in `<script>`, self-promotion (absolute links back to the newsletter's own domain are treated as internal), and organic "in partnership with…" prose are all filtered out.
- **Fails gracefully, bills honestly** — an unsupported platform (e.g. a custom Next.js site like Milk Road) returns a single `unsupported_platform` record; an unreachable site returns a single `error` record; per-issue fetch failures are retried (2 retries with backoff), then counted in the newsletter's summary (`issues_failed`) instead of being pushed as junk rows. At most one error record per newsletter URL.
- **Streams results** — each item is pushed to the dataset the moment it is scraped, so a timeout or migration keeps everything collected so far.

### Output fields

One dataset item per successfully read issue (`type: "issue"`), plus an optional per-newsletter summary. Every record carries the same key set (summary-only fields are `null` on issue records and vice versa).

```json
{
  "type": "issue",
  "newsletter": "https://www.therundown.ai",
  "platform": "beehiiv",
  "url": "https://www.therundown.ai/p/google-gemini-lineup-has-a-pro-sized-hole",
  "slug": "google-gemini-lineup-has-a-pro-sized-hole",
  "date": "2026-07-22",
  "title": "Google’s Gemini lineup has a Pro-sized hole",
  "is_paid_truncated": false,
  "sponsor_count": 2,
  "sponsors": [
    {
      "name": "Unwrap",
      "marker_phrase": "together with",
      "link": "https://cal.com/unwrap/quick-connect",
      "utm_source": null,
      "utm_campaign": null
    },
    {
      "name": "Google for Startups",
      "marker_phrase": "presented by",
      "link": "https://cloud.google.com/startup",
      "utm_source": null,
      "utm_campaign": null
    }
  ],
  "scraped_at": "2026-07-23T08:15:00.000000+00:00",
  "error": null,
  "issues_found": null,
  "issues_with_sponsors": null,
  "total_sponsors": null,
  "issues_failed": null
}
````

| Field | Meaning |
|---|---|
| `type` | `issue`, `newsletter_summary`, `unsupported_platform`, or `error` |
| `newsletter` | Base URL of the publication |
| `platform` | `substack`, `beehiiv`, `ghost`, or `unsupported` |
| `url`, `slug`, `date`, `title` | Issue identity |
| `is_paid_truncated` | `true` when a Substack paid issue returned only the free preview (late-body ads may be missed; sponsor blocks usually sit above the paywall) |
| `sponsor_count` | Number of distinct sponsors found in the issue |
| `sponsors[]` | `name`, `marker_phrase`, `link`, `utm_source`, `utm_campaign` |
| `scraped_at` | ISO timestamp of the scrape (every record) |
| `error` | Error message: on an `error`/`unsupported_platform` record the reason; on a `newsletter_summary` the first per-issue fetch error, if any |
| `issues_found` | Summary only: issues successfully read for this newsletter |
| `issues_with_sponsors` | Summary only: how many of those issues carried at least one sponsor |
| `total_sponsors` | Summary only: total sponsor mentions across the issues |
| `issues_failed` | Summary only: issue fetches that still failed after retries (not billed as rows) |

### Input

| Field | Type | Description |
|---|---|---|
| `newsletterUrls` | array (required) | Newsletter home/base URLs. Platform is auto-detected. An explicitly empty list runs nothing (the demo defaults apply only when the field is omitted). |
| `maxIssuesPerNewsletter` | integer | Most-recent issues to read per newsletter (default 3). Each successfully read issue is one billed result; Ghost is capped at its ~15-issue RSS window. |
| `dateFloor` | string | Optional ISO date (`YYYY-MM-DD`); skip issues published before it. Any other format fails the run immediately, before any billing. |
| `includeSummary` | boolean | Emit a per-newsletter `newsletter_summary` record (default true). If disabled and fetches failed, a single `error` record still reports the failures. |
| `requestDelay` | integer | Polite seconds between requests (default 2). |
| `proxyConfiguration` | object | Apify Proxy config. Datacenter is the default; switch to **residential** if Substack/beehiiv challenge you. |

Minimal input:

```json
{
  "newsletterUrls": ["https://www.therundown.ai", "https://blog.bytebytego.com"],
  "maxIssuesPerNewsletter": 5
}
```

### A pay-per-use alternative to Who Sponsors Stuff, Rephonic, and Podscan — no monthly seat

The incumbent sponsor-intelligence tools are subscriptions: Who Sponsors Stuff is a yearly contract, Rephonic runs $99–299/month, Podscan $100+/month — and none of them lets you point the crawl at the exact newsletters *you* care about, or hands you the raw `utm_source`/`utm_campaign` attribution as data you own.

This actor turns "who sponsors my competitor's newsletter?" from a monthly seat into a few-dollar sweep: at **$0.01 per result**, scanning 50 newsletters × 5 recent issues ≈ 300 results ≈ **$3** all-in, pay-per-use, structured JSON out. Run it once for a campaign or on a weekly schedule for a rolling sponsor database.

### Who sponsors my competitor's newsletter? (reverse prospecting for ad sales)

The highest-value use: find **which brands are actively buying newsletter sponsorships in your niche**, then pitch them your inventory — they are already spending.

1. List the newsletters your advertisers (or your competitors' advertisers) appear in.
2. Run with `dateFloor` set to ~30 days back to capture the current buying cycle.
3. Pivot the `sponsors[]` records by `name`: brands appearing across multiple newsletters are active category buyers; their `utm_campaign` values often reveal the campaign scope and naming conventions.

### Use cases

- **Ad-sales prospecting** — find every brand already buying newsletter placements in your vertical, and pitch the ones spending near you.
- **Competitive ad intelligence** — track which competitors sponsor which newsletters, and how frequently, over time.
- **Sponsorship rate benchmarking** — map sponsor frequency across a set of newsletters to estimate demand and inventory.
- **Media-buying research** — before booking a newsletter, see who else advertises there and what their landing pages / UTM conventions look like.
- **Newsletter marketplaces & databases** — enrich a directory of newsletters with live sponsor rosters.
- **Brand monitoring** — watch for your own or a competitor's brand appearing in newsletter ad slots.

### FAQ

#### How do I find out who sponsors a newsletter?

Point this actor at the newsletter's URL. It reads the public issue content directly over HTTP and returns the sponsor brands, marker phrases, landing links, and UTM tags per issue — no publisher API, no account, no key. Works on Substack (including custom domains), beehiiv, and Ghost.

#### How do I extract sponsors and advertisers from beehiiv and Ghost newsletters?

The same way — paste the beehiiv or Ghost URL into `newsletterUrls`. beehiiv issues are enumerated via the archive and sitemap; Ghost via its full-content RSS feed. Both return the identical structured sponsor records as Substack.

#### Which newsletter platforms are supported?

Substack (including custom domains), beehiiv, and Ghost. Other/custom platforms return a single `unsupported_platform` record so your run never breaks.

#### Does this scrape private inboxes?

**No — you supply the public newsletter URLs you choose to monitor.** The actor reads only the public issue archive pages each platform serves; there is no inbox access, no login, and no private content.

#### How accurate is it?

**1.000 precision and recall on our ground-truth test set** across Substack, beehiiv, and Ghost — every extraction is deterministic heuristics corroborated by the ad block's outbound link, so results are reproducible run to run.

#### Does it use an LLM to detect sponsors?

No. Detection is deterministic heuristics — marker phrases plus outbound-link corroboration — so results are fast, cheap, and reproducible.

#### Can it read paid / members-only issues?

It reads the free preview that the platform serves publicly. Sponsor blocks are usually placed above the paywall, so they are typically captured; `is_paid_truncated` flags issues where later content was cut.

#### Will I get blocked?

Requests use an honest desktop User-Agent with a polite delay and no CAPTCHA/WAF evasion. Substack is Cloudflare-fronted and beehiiv uses a CDN; if datacenter IPs are challenged, select the **residential** proxy group in `proxyConfiguration`.

#### How is it billed?

Pay-per-result: one item per successfully read issue, plus one optional summary per newsletter. Failed fetches are never billed as rows — they are retried, then aggregated into the summary's `issues_failed` count (at most one `error` record per newsletter URL). Use `maxIssuesPerNewsletter` and `dateFloor` to control volume and cost.

### Notes & limitations

- Image-only sponsor logo strips with no adjacent link or text can be missed (no brand text to read).
- Sponsor names lifted from all-caps ad headers are naively title-cased (e.g. `TOGETHER WITH CDATA` → `Cdata`); exact stylization (`CData`, `iPhone`-style casing) may differ from the brand's own.
- Ghost newsletters expose only their RSS window (~15 newest issues); a larger `maxIssuesPerNewsletter` logs a warning and returns what the feed offers. There is no deeper Ghost backfill in v1.
- Respect each publication's terms of service. This actor reads public web content for analytics; you are responsible for how you use the output.

# Actor input Schema

## `newsletterUrls` (type: `array`):

One or more newsletter home/base URLs (e.g. https://www.therundown.ai, https://blog.bytebytego.com, https://www.platformer.news). The actor auto-detects the platform (Substack incl. custom domains, beehiiv, or Ghost) and reads recent issues. Unsupported platforms (custom Next.js sites like Milk Road) return a single 'unsupported\_platform' record instead of failing; an unreachable site returns a single 'error' record. An explicitly empty list runs nothing. You are billed per result, so more newsletters x more issues = more items.

## `maxIssuesPerNewsletter` (type: `integer`):

How many of the most recent issues to read per newsletter (newest first). Each successfully read issue becomes one billed result (failed fetches are not billed; they are counted in the summary's issues\_failed). Substack and beehiiv page/backfill to this depth; Ghost is capped at its RSS window (~15 newest issues) — larger values log a warning. Keep this small for a quick scan; raise it for a deeper sponsor history.

## `dateFloor` (type: `string`):

Optional ISO date (YYYY-MM-DD). Issues published before this date are skipped, so you can pull just the last month of sponsors instead of a fixed count. Any other format fails the run immediately (before any billing). Leave empty to use maxIssuesPerNewsletter alone.

## `includeSummary` (type: `boolean`):

Emit one extra item per newsletter (type: 'newsletter\_summary') with issues scanned, issues with sponsors, and total sponsor mentions. Handy for dashboards. These summary items are billed like ordinary results (one extra item per newsletter).

## `requestDelay` (type: `integer`):

Polite pause between HTTP requests to the same publication. 1-2 seconds is respectful and is what was verified during development. Lower values risk rate-limiting; there is no CAPTCHA/WAF evasion.

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

Proxies for the HTTP requests. Substack is Cloudflare-fronted and beehiiv uses a CDN, so datacenter IPs (the default Apify Proxy) usually work but can occasionally see challenges. If you get blocked, switch this to the RESIDENTIAL proxy group. Ghost sites are self-hosted and are fine on datacenter.

## Actor input object example

```json
{
  "newsletterUrls": [
    "https://www.therundown.ai",
    "https://www.platformer.news"
  ],
  "maxIssuesPerNewsletter": 3,
  "dateFloor": "2026-06-01",
  "includeSummary": true,
  "requestDelay": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# 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 = {
    "newsletterUrls": [
        "https://www.therundown.ai",
        "https://www.platformer.news"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentshadow55/newsletter-sponsors-actor").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 = {
    "newsletterUrls": [
        "https://www.therundown.ai",
        "https://www.platformer.news",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("silentshadow55/newsletter-sponsors-actor").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 '{
  "newsletterUrls": [
    "https://www.therundown.ai",
    "https://www.platformer.news"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call silentshadow55/newsletter-sponsors-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=silentshadow55/newsletter-sponsors-actor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Newsletter Sponsorship Intelligence — Substack, beehiiv & Ghost",
        "description": "Extract sponsors and ad placements from Substack, beehiiv, and Ghost newsletters. Give it newsletter URLs and get, per issue: the sponsor brand names, the marker phrase (Presented by / Together with / Sponsored by), the sponsor link, and utm_source / utm_campaign. Pure HTTP, no logins, no LLM.",
        "version": "0.0",
        "x-build-id": "9dMTjzb51tBaRoXpM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentshadow55~newsletter-sponsors-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentshadow55-newsletter-sponsors-actor",
                "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/silentshadow55~newsletter-sponsors-actor/runs": {
            "post": {
                "operationId": "runs-sync-silentshadow55-newsletter-sponsors-actor",
                "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/silentshadow55~newsletter-sponsors-actor/run-sync": {
            "post": {
                "operationId": "run-sync-silentshadow55-newsletter-sponsors-actor",
                "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": [
                    "newsletterUrls"
                ],
                "properties": {
                    "newsletterUrls": {
                        "title": "Newsletter URLs",
                        "type": "array",
                        "description": "One or more newsletter home/base URLs (e.g. https://www.therundown.ai, https://blog.bytebytego.com, https://www.platformer.news). The actor auto-detects the platform (Substack incl. custom domains, beehiiv, or Ghost) and reads recent issues. Unsupported platforms (custom Next.js sites like Milk Road) return a single 'unsupported_platform' record instead of failing; an unreachable site returns a single 'error' record. An explicitly empty list runs nothing. You are billed per result, so more newsletters x more issues = more items.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxIssuesPerNewsletter": {
                        "title": "Max issues per newsletter",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many of the most recent issues to read per newsletter (newest first). Each successfully read issue becomes one billed result (failed fetches are not billed; they are counted in the summary's issues_failed). Substack and beehiiv page/backfill to this depth; Ghost is capped at its RSS window (~15 newest issues) — larger values log a warning. Keep this small for a quick scan; raise it for a deeper sponsor history.",
                        "default": 3
                    },
                    "dateFloor": {
                        "title": "Only issues on/after this date",
                        "pattern": "^$|^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                        "type": "string",
                        "description": "Optional ISO date (YYYY-MM-DD). Issues published before this date are skipped, so you can pull just the last month of sponsors instead of a fixed count. Any other format fails the run immediately (before any billing). Leave empty to use maxIssuesPerNewsletter alone."
                    },
                    "includeSummary": {
                        "title": "Include per-newsletter summary record",
                        "type": "boolean",
                        "description": "Emit one extra item per newsletter (type: 'newsletter_summary') with issues scanned, issues with sponsors, and total sponsor mentions. Handy for dashboards. These summary items are billed like ordinary results (one extra item per newsletter).",
                        "default": true
                    },
                    "requestDelay": {
                        "title": "Delay between requests (seconds)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Polite pause between HTTP requests to the same publication. 1-2 seconds is respectful and is what was verified during development. Lower values risk rate-limiting; there is no CAPTCHA/WAF evasion.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxies for the HTTP requests. Substack is Cloudflare-fronted and beehiiv uses a CDN, so datacenter IPs (the default Apify Proxy) usually work but can occasionally see challenges. If you get blocked, switch this to the RESIDENTIAL proxy group. Ghost sites are self-hosted and are fine on datacenter.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```