# Newsletter Sponsors Scraper — InboxReads Directory (`nomad-agent/newsletter-sponsors-scraper`) Actor

Find newsletters that accept sponsorships, cross-promotions or are up for sale — scraped from the InboxReads public directory. Topics, cadence, audience geography, email tooling and sponsor-contact signals per newsletter. Built for sponsor prospecting and newsletter market research.

- **URL**: https://apify.com/nomad-agent/newsletter-sponsors-scraper.md
- **Developed by:** [Nomad.Dev](https://apify.com/nomad-agent) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.60 / 1,000 newsletter results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Newsletter Sponsors Scraper — InboxReads Directory

Find newsletters that **accept sponsorships**, are **open to cross-promotion** or are **up for sale** — scraped from the [InboxReads](https://inboxreads.co) public directory (~3,300 newsletters). Per newsletter: topics, send cadence, audience geography, the email/sponsorship tooling it runs on (Paved, BuySellAds, Passionfroot, beehiiv, Mailchimp...), whether a sponsor-contact route exists, and directory popularity ranks. No login, no proxies.

Built for **sponsor prospecting** (media buyers and brands hunting placement inventory), **newsletter competitive research**, and **acquisition scouting** (`onlyForSale`).

### What makes this different

Other InboxReads scrapers return name, description and topics. This one is built around **sponsor intelligence** — a combination of first-class, filterable fields no other newsletter-directory Actor exposes:

- `acceptsSponsorships`, `allowsCrossPromotion`, `isForSale` — filter the directory straight down to buyable / swappable / acquirable inventory.
- `sponsorshipPlatforms` — the ad networks a newsletter actually sells through (Paved, BuySellAds, Passionfroot...), **detected from its tooling stack rather than self-reported**, so you know *where to go buy*. Filter on it directly.
- `hasSponsorContact` / `hasAdvertiseUrl` — whether a contact route / media kit exists.
- `audienceCountries` — reader geography, for market-matched buys.

**On the fields we deliberately leave out:** we do not emit subscriber counts or open/click rates. InboxReads gates those behind its Pro plan on every public listing, so a scraper can only ever return them as `null` (or a fabricated guess). We return what is actually public and skip the always-empty columns — see the FAQ below.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `topics` | array of strings | `["business", "marketing"]` | Only newsletters tagged with at least one of these topics (case-insensitive). Empty list = all topics. Full topic list: [inboxreads.co/topics](https://inboxreads.co/topics). |
| `onlyAcceptingSponsors` | boolean | `false` | Only newsletters whose listing says they accept paid sponsorships/ads (roughly half the directory). |
| `onlyOpenToCrossPromotion` | boolean | `false` | Only newsletters open to cross-promotion swaps. |
| `onlyForSale` | boolean | `false` | Only newsletters marked as up for sale. |
| `sponsorshipPlatforms` | array of strings | *(empty)* | Only newsletters that sell sponsorships through at least one of these platforms (case-insensitive), e.g. `Paved`, `BuySellAds`, `Passionfroot`. Detected from the tooling stack, not self-reported. Empty = any platform. |
| `language` | string | *(empty)* | Only newsletters written in this language, e.g. `english`, `spanish`. Empty = any. |
| `onlyNewSinceLastRun` | boolean | `false` | Only output newsletters not seen in previous runs with this flag — see [Delta mode](#delta-mode). |
| `maxItems` | integer | `100` | Hard cap on directory listings fetched (considered) per run. `0` = the whole directory (~3,300 listings — use with care). With filters on, fewer records may actually be pushed and billed. |
| `concurrency` *(Advanced)* | integer | `4` | Parallel listing fetches. Keep low — this is a small independent directory site. |

### What newsletter data does this scraper extract?

One flat JSON record per newsletter listing:

| Field | Meaning |
|---|---|
| `id` | Stable id, `inboxreads:<slug>` |
| `source` | Always `inboxreads` |
| `slug` | Listing slug |
| `url` | Listing page on InboxReads |
| `name` | Newsletter name |
| `tagline` | One-line pitch |
| `description` | Longer description |
| `topics` | Topic tags, e.g. `["business", "tech"]` |
| `language` | Language, e.g. `english` |
| `sendIntervalDays` | Send cadence in days (`1` = daily, `7` = weekly) — `null` if not stated |
| `sendFrequency` | Human label derived from the above (`daily`, `weekly`, `biweekly`, ...) |
| `acceptsSponsorships` | `true` if the listing says it accepts paid sponsorships/ads |
| `allowsCrossPromotion` | `true` if open to cross-promo swaps |
| `isForSale` | `true` if the newsletter is listed for sale |
| `paidStatus` | `free` / paid-subscription status of the newsletter itself |
| `hasSponsorContact` | `true` if the directory exposes a contact route for this newsletter |
| `hasAdvertiseUrl` | `true` if the newsletter publishes its own advertise/media-kit link |
| `favourites` | Directory likes — popularity proxy |
| `ranks` | Directory rank overall and per topic, e.g. `{"all": 1, "news": 1}` |
| `audienceCountries` | Top reader countries with relative score, `[{"country", "score"}]` |
| `audienceCountryCount` | How many countries the readership spans |
| `emailTools` | Detected stack, `[{"name", "category"}]` — category `sponsorship` shows which sales platform (Paved, BuySellAds, Passionfroot...) the newsletter sells through |
| `sponsorshipPlatforms` | Flat list of the sponsorship sales platforms from `emailTools`, e.g. `["Paved", "BuySellAds"]` — the actionable "where to go buy" signal, and the `sponsorshipPlatforms` input filters on it |
| `listingCreatedAt` / `listingUpdatedAt` | Listing timestamps (ISO 8601) |
| `relatedSlugs` | Similar newsletters (slugs) — feed them back in as seeds |
| `parseConfidence` | `high` / `medium` / `low` — how cleanly the page parsed |
| `warnings` | Parse warnings, empty when clean |
| `isNew` | `true` on every pushed record — only present when **Only new since last run** is on |

Subscriber counts and open/click rates are **not** included: InboxReads gates them behind its Pro plan on every listing we sampled, and this actor only reads public pages — no always-empty columns, no fabricated numbers.

### How to find newsletter sponsorship inventory with this Actor

1. Set **topics** to your target verticals (`marketing`, `finance`, `ai`, ...) — or leave empty for the whole directory.
2. Turn on **Only newsletters accepting sponsors** to keep just the sponsorable inventory; add **language** if you buy in one market.
3. Read `sponsorshipPlatforms` in the output — the platforms (Paved, BuySellAds, Passionfroot...) where that newsletter actually sells placements, i.e. where to go buy. To target one ad network, put its name in the **Sponsorship platforms** input (e.g. `["Paved"]`) and only newsletters selling through it come back.
4. Turn on **Only new since last run** and schedule the run to monitor newly listed newsletters (new inventory alert).
5. Export JSON, CSV or Excel — or call it over the API:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nomad-agent/newsletter-sponsors-scraper").call(run_input={
    "topics": ["marketing", "business"],
    "onlyAcceptingSponsors": True,
    "maxItems": 200,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], "|", item["sendFrequency"], "|", item["url"])
````

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nomad-agent~newsletter-sponsors-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"topics": ["marketing"], "onlyAcceptingSponsors": true, "maxItems": 100}'
```

### Output example

Real record (fetched 2026-07-02):

```json
{
  "id": "inboxreads:theskimm",
  "source": "inboxreads",
  "slug": "theskimm",
  "url": "https://inboxreads.co/n/theskimm",
  "name": "Daily Skimm",
  "tagline": "The morning newsletter that millions wake up to",
  "description": "Meet, news without all the noise. The Daily Skimm connects the dots on how the day's biggest stories affect your life.",
  "topics": ["news", "business", "sports", "politics", "entertainment"],
  "language": "english",
  "sendIntervalDays": 1,
  "sendFrequency": "daily",
  "acceptsSponsorships": true,
  "allowsCrossPromotion": false,
  "isForSale": false,
  "paidStatus": "free",
  "hasSponsorContact": false,
  "hasAdvertiseUrl": true,
  "favourites": 174,
  "ranks": {"all": 2, "news": 2, "sports": 2, "business": 2, "politics": 2, "entertainment": 1},
  "audienceCountries": [
    {"country": "United States", "score": 191},
    {"country": "India", "score": 22},
    {"country": "Morocco", "score": 14},
    {"country": "Brazil", "score": 12},
    {"country": "Canada", "score": 12}
  ],
  "audienceCountryCount": 1835,
  "emailTools": [
    {"name": "Paved", "category": "sponsorship"},
    {"name": "BuySellAds", "category": "sponsorship"},
    {"name": "Marigold Engage by Sailthru", "category": "email service provider"}
  ],
  "sponsorshipPlatforms": ["Paved", "BuySellAds"],
  "listingCreatedAt": "2017-09-08T16:45:16.000Z",
  "listingUpdatedAt": "2024-09-24T22:30:18.311Z",
  "relatedSlugs": ["axios-am-pm", "need-2-know", "tip-news", "1440-daily-digest", "daily-dose-1", "boardroom-newsletters"],
  "parseConfidence": "high",
  "warnings": []
}
```

`isNew` (delta mode) is added on top of this shape when that input is used.

### Delta mode

Turn on **Only new since last run** (`onlyNewSinceLastRun`) to have the Actor remember which listings it has already returned (keyed by slug) across runs and skip them.

- Skipped (already-seen) listings are **not fetched, not pushed and not billed** — repeat runs only pay for newsletters newly added to the directory.
- Every record pushed with this flag on is tagged `"isNew": true`.
- State is kept in a dedicated key-value store (separate from the run's default store), so it persists across scheduled runs.
- Failed fetches are *not* marked as seen — they retry on the next run.

### Pricing

Pay per event: **$0.05 per Actor start** + **$0.004 per newsletter record** pushed. Filters run before billing — records filtered out are never charged. A full-directory sweep (`maxItems: 0`, no filters) is ~3,300 records ≈ $13.25; a typical filtered topic run (`maxItems: 100`) costs at most $0.45.

### FAQ

**Where does the data come from?** The public InboxReads directory (inboxreads.co) — listing pages only. The actor respects the site's robots.txt: InboxReads' own media-kit, ad-rate, sponsor-list and API paths are disallowed there and are never fetched.

**Why are there no subscriber counts or CPM prices?** InboxReads gates subscriber/open-rate/click-rate metrics behind its Pro plan, and newsletter rate cards live on each newsletter's own media-kit page. This actor reports what is public: sponsorship acceptance flags, contact/advertise-URL signals and which sponsorship platform each newsletter sells through (`emailTools`) — enough to build a prospect list; pricing conversations happen on the newsletter's own advertise page.

**How fresh is the data?** Each run fetches live pages. `listingUpdatedAt` tells you when the newsletter's listing itself last changed.

**Some fields are null — why?** Newsletters self-report unevenly. Fields the listing doesn't state come back `null` (never guessed); `parseConfidence` + `warnings` flag records where the page shape looked unusual.

**Can I monitor for new newsletters?** Yes — schedule the actor with `onlyNewSinceLastRun: true`. Only newly listed newsletters are pushed (and billed) on each run.

### Integrations

Export results as JSON, CSV or Excel, or wire this Actor into [Make](https://make.com), [Zapier](https://zapier.com) or [n8n](https://n8n.io); call it programmatically with `run-sync-get-dataset-items`; or use it from AI agents via the [Apify MCP server](https://mcp.apify.com).

# Actor input Schema

## `topics` (type: `array`):

Only newsletters tagged with at least one of these topics (case-insensitive), e.g. <code>business</code>, <code>tech</code>, <code>marketing</code>, <code>finance</code>, <code>ai</code>. Empty = all topics. Browse the full topic list at inboxreads.co/topics.

## `onlyAcceptingSponsors` (type: `boolean`):

Only newsletters whose listing says they accept paid sponsorships/ads. Roughly half the directory qualifies.

## `onlyOpenToCrossPromotion` (type: `boolean`):

Only newsletters open to cross-promotion swaps with other newsletters.

## `onlyForSale` (type: `boolean`):

Only newsletters whose listing is marked as up for sale (acquisition leads).

## `sponsorshipPlatforms` (type: `array`):

Only newsletters that sell sponsorships through at least one of these platforms (case-insensitive), e.g. <code>Paved</code>, <code>BuySellAds</code>, <code>Passionfroot</code>. Detected from each newsletter's tooling stack, not self-reported — see the <code>sponsorshipPlatforms</code> output field. Empty = any platform. Combine with <code>onlyAcceptingSponsors</code> to target buyable inventory sold through a specific ad network.

## `language` (type: `string`):

Only newsletters written in this language, e.g. <code>english</code>, <code>spanish</code>, <code>german</code>. Empty = any language.

## `onlyNewSinceLastRun` (type: `boolean`):

Only output newsletters not seen in previous runs with this flag — new-listing monitoring. Skipped (already-seen) listings are not fetched, pushed or billed.

## `maxItems` (type: `integer`):

Hard cap on directory listings fetched (considered) per run. 0 = the whole directory (~3,300 listings — use with care). With filters on, fewer records than this may actually be pushed and billed.

## `concurrency` (type: `integer`):

How many listing pages to fetch in parallel. Keep low — this is a small independent directory site.

## Actor input object example

```json
{
  "topics": [
    "business",
    "marketing"
  ],
  "onlyAcceptingSponsors": false,
  "onlyOpenToCrossPromotion": false,
  "onlyForSale": false,
  "onlyNewSinceLastRun": false,
  "maxItems": 100,
  "concurrency": 4
}
```

# Actor output Schema

## `dataset` (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 = {
    "topics": [
        "business",
        "marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nomad-agent/newsletter-sponsors-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "topics": [
        "business",
        "marketing",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nomad-agent/newsletter-sponsors-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "topics": [
    "business",
    "marketing"
  ]
}' |
apify call nomad-agent/newsletter-sponsors-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Newsletter Sponsors Scraper — InboxReads Directory",
        "description": "Find newsletters that accept sponsorships, cross-promotions or are up for sale — scraped from the InboxReads public directory. Topics, cadence, audience geography, email tooling and sponsor-contact signals per newsletter. Built for sponsor prospecting and newsletter market research.",
        "version": "0.1",
        "x-build-id": "P8mhMY50N2mvmamWu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nomad-agent~newsletter-sponsors-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nomad-agent-newsletter-sponsors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nomad-agent~newsletter-sponsors-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nomad-agent-newsletter-sponsors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nomad-agent~newsletter-sponsors-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nomad-agent-newsletter-sponsors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "topics": {
                        "title": "Topics",
                        "type": "array",
                        "description": "Only newsletters tagged with at least one of these topics (case-insensitive), e.g. <code>business</code>, <code>tech</code>, <code>marketing</code>, <code>finance</code>, <code>ai</code>. Empty = all topics. Browse the full topic list at inboxreads.co/topics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyAcceptingSponsors": {
                        "title": "Only newsletters accepting sponsors",
                        "type": "boolean",
                        "description": "Only newsletters whose listing says they accept paid sponsorships/ads. Roughly half the directory qualifies.",
                        "default": false
                    },
                    "onlyOpenToCrossPromotion": {
                        "title": "Only newsletters open to cross-promotion",
                        "type": "boolean",
                        "description": "Only newsletters open to cross-promotion swaps with other newsletters.",
                        "default": false
                    },
                    "onlyForSale": {
                        "title": "Only newsletters for sale",
                        "type": "boolean",
                        "description": "Only newsletters whose listing is marked as up for sale (acquisition leads).",
                        "default": false
                    },
                    "sponsorshipPlatforms": {
                        "title": "Sponsorship platforms",
                        "type": "array",
                        "description": "Only newsletters that sell sponsorships through at least one of these platforms (case-insensitive), e.g. <code>Paved</code>, <code>BuySellAds</code>, <code>Passionfroot</code>. Detected from each newsletter's tooling stack, not self-reported — see the <code>sponsorshipPlatforms</code> output field. Empty = any platform. Combine with <code>onlyAcceptingSponsors</code> to target buyable inventory sold through a specific ad network.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Only newsletters written in this language, e.g. <code>english</code>, <code>spanish</code>, <code>german</code>. Empty = any language."
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "Only output newsletters not seen in previous runs with this flag — new-listing monitoring. Skipped (already-seen) listings are not fetched, pushed or billed.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on directory listings fetched (considered) per run. 0 = the whole directory (~3,300 listings — use with care). With filters on, fewer records than this may actually be pushed and billed.",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many listing pages to fetch in parallel. Keep low — this is a small independent directory site.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
