# Substack Publication and Post Scraper (`esrok/substack-publication-and-post-scraper`) Actor

Extract public Substack posts, authors, publication details, dates, URLs, excerpts, images, tags, visible engagement counts, and public article text for research, competitor tracking, market analysis, and AI workflows. No login and no paywall bypass.

- **URL**: https://apify.com/esrok/substack-publication-and-post-scraper.md
- **Developed by:** [Esrok](https://apify.com/esrok) (community)
- **Categories:** Social media, News, AI
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 public post results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Substack Publication and Post Scraper

Extract clean public Substack posts, article text, author names, publication metadata, dates, images, tags, and engagement counts. Built for AI summaries, newsletter research, market intelligence, and competitor content monitoring.

Best for AI builders, researchers, agencies, newsletter operators, and content teams who need clean public Substack data without manual copying.

Substack Publication and Post Scraper turns public Substack publication URLs and post URLs into a structured dataset you can export, analyze, summarize, or send into automation workflows.

It does not log in, bypass paywalls, scrape subscriber-only content, or collect hidden private data. If a post is paid or preview-only, the Actor returns only the publicly visible preview information and marks it as `preview_only`.

### What this Actor does

Enter one or more public Substack publication URLs or direct post URLs. The Actor reads public publication pages, public RSS feeds, and public post pages, then returns spreadsheet-ready rows in the Apify dataset.

It can extract:

- Publication name, URL, description, logo, and visible topic/category
- Post title, URL, slug, dates, excerpt, image, tags, and public article text
- Public author name and author profile URL when visible
- Visible likes and comments counts when available on the public page
- Public access status: `public`, `preview_only`, or `unavailable`
- Source input URL and scrape timestamp for every result

### Why use it

This Actor focuses on public-only, no-login Substack extraction with clean spreadsheet-ready output and simple pricing per result.

It is designed for users who want a reliable dataset, not a messy scrape. Each result is shaped for CSV, Excel, JSON, API usage, AI content datasets, RAG pipelines, newsletter monitoring, and automated summaries.

Use it when you want:

- Clean output columns that are easy to filter in a spreadsheet
- Public article text for AI summaries and research workflows
- A simple input form for publication URLs and post URLs
- Clear labeling for public, preview-only, and unavailable posts
- A responsible public-data scraper that avoids private or paid content

### Use cases

- Build AI content datasets from public Substack posts
- Feed public article text into RAG pipelines or summarization workflows
- Monitor public posts from newsletters in a niche
- Track competitor newsletters and monitor what top writers in your niche are publishing
- Research authors, publications, topics, and market narratives
- Export public newsletter data to CSV, Excel, JSON, or API
- Send new public posts to Make, Zapier, n8n, Google Sheets, Airtable, Notion, Slack, or custom systems
- Support market intelligence, media monitoring, and founder research workflows

### Input

At least one `publicationUrls` or `postUrls` entry is required.

| Field | Type | Description |
| --- | --- | --- |
| `publicationUrls` | array | Public Substack publication URLs, for example `https://astralcodexten.substack.com`. The Actor reads public metadata and public RSS feeds. |
| `postUrls` | array | Optional direct public Substack post URLs. Useful when you already know the exact posts to extract. |
| `maxPostsPerPublication` | integer | Maximum posts to collect from each publication feed. Default is `25`; maximum is `500`. |
| `includePostText` | boolean | Include publicly visible article body text or public preview text. Default is `true`. |
| `includeExcerpt` | boolean | Include public excerpts from RSS or page metadata. Default is `true`. |
| `includeAuthorInfo` | boolean | Include public author name and URL when visible. Default is `true`. |
| `includePublicationInfo` | boolean | Include publication name, URL, description, logo, and topic when available. Default is `true`. |
| `dateFrom` | string or null | Optional start date filter, such as `2026-01-01`. |
| `dateTo` | string or null | Optional end date filter, such as `2026-12-31`. |
| `deduplicateResults` | boolean | Remove duplicate posts across publication feeds and direct post URLs. Default is `true`. |
| `maxConcurrency` | integer | Advanced option for parallel public post page requests. Default is `5`. |
| `requestTimeoutSecs` | integer | Advanced request timeout. Default is `30`. |
| `maxRetries` | integer | Advanced retry count for temporary network errors. Default is `2`. |

### Output

Each dataset item is one public Substack post record.

| Field | Description |
| --- | --- |
| `publicationName` | Public publication name when available |
| `publicationUrl` | Public publication URL |
| `publicationDescription` | Public publication description |
| `publicationLogo` | Public logo/image URL |
| `publicationTopic` | Visible topic or category when available |
| `postTitle` | Public post title |
| `postUrl` | Public post URL |
| `postSlug` | Post slug parsed from the URL |
| `authorName` | Public author name when visible |
| `authorUrl` | Public author URL when visible |
| `publishedAt` | Published date when available |
| `updatedAt` | Updated date when available |
| `excerpt` | Public excerpt when enabled |
| `publicPostText` | Public article text or public preview text when enabled |
| `isPaidPreview` | Whether the post appears to be paid/preview-only |
| `isPubliclyReadable` | Whether public article text was readable |
| `accessStatus` | `public`, `preview_only`, or `unavailable` |
| `likesCount` | Visible likes count when available |
| `commentsCount` | Visible comments count when available |
| `imageUrl` | Main image URL when visible |
| `tags` | Visible tags when available |
| `sourceInputUrl` | Original input URL that led to the result |
| `scrapedAt` | Timestamp when the row was scraped |

The Actor also writes `RUN_SUMMARY` to the default key-value store with result counts, warnings, and run status.

### Example input

```json
{
  "publicationUrls": ["https://astralcodexten.substack.com"],
  "postUrls": [],
  "maxPostsPerPublication": 10,
  "includePostText": true,
  "includeExcerpt": true,
  "includeAuthorInfo": true,
  "includePublicationInfo": true,
  "dateFrom": null,
  "dateTo": null,
  "deduplicateResults": true,
  "maxConcurrency": 5
}
````

Direct post example:

```json
{
  "publicationUrls": [],
  "postUrls": [
    "https://www.astralcodexten.com/p/book-review-the-dialectical-imagination"
  ],
  "maxPostsPerPublication": 1,
  "includePostText": true,
  "deduplicateResults": true
}
```

### Example output

```json
{
  "publicationName": "Astral Codex Ten",
  "publicationUrl": "https://www.astralcodexten.com",
  "publicationDescription": "P(A|B) = [P(A)*P(B|A)]/P(B), all the rest is commentary.",
  "publicationLogo": "https://substackcdn.com/image/fetch/...",
  "publicationTopic": null,
  "postTitle": "Book Review: The Dialectical Imagination",
  "postUrl": "https://www.astralcodexten.com/p/book-review-the-dialectical-imagination",
  "postSlug": "book-review-the-dialectical-imagination",
  "authorName": "Scott Alexander",
  "authorUrl": null,
  "publishedAt": "2026-05-29T15:01:57.000Z",
  "updatedAt": "2026-05-29T15:01:57.859Z",
  "excerpt": "Public excerpt text...",
  "publicPostText": "The visible public article text or public preview text...",
  "isPaidPreview": false,
  "isPubliclyReadable": true,
  "accessStatus": "public",
  "likesCount": 22,
  "commentsCount": null,
  "imageUrl": "https://substackcdn.com/image/fetch/...",
  "tags": [],
  "sourceInputUrl": "https://astralcodexten.substack.com",
  "scrapedAt": "2026-05-29T12:00:00.000Z"
}
```

### How to run

1. Open the Actor in Apify.
2. Add one or more public Substack publication URLs or direct post URLs.
3. Set `maxPostsPerPublication`.
4. Choose whether to include public post text, excerpts, author info, and publication info.
5. Add optional date filters if you only want posts from a specific period.
6. Run the Actor.
7. Open the Dataset tab to view or export the results.

For scheduled monitoring, create an Apify schedule and use date filters or downstream deduplication to process only new rows.

### Export and integrations

Apify datasets can be exported as:

- CSV
- Excel
- JSON
- JSONL
- XML
- RSS

You can use the results with:

- Apify API
- Make
- Zapier
- n8n
- Google Sheets
- Airtable
- Notion
- Slack alerts
- AI summarization tools
- RAG pipelines and vector databases

Example API run:

```text
curl "https://api.apify.com/v2/acts/esrok~substack-publication-and-post-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "publicationUrls": ["https://astralcodexten.substack.com"],
    "maxPostsPerPublication": 10,
    "includePostText": true
  }'
```

Read dataset items after the run finishes:

```text
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true&token=YOUR_APIFY_TOKEN"
```

### Responsible use

Use this Actor only for public research, content monitoring, and analysis of publicly visible Substack pages.

Do not use it to bypass paywalls, access paid subscriber-only content, collect private user data, scrape login-only pages, or violate Substack's terms or creator rights.

The Actor does not use login sessions, cookies, or subscriber accounts. It reads public RSS feeds and public post pages. If a paid post exposes only a preview, the Actor returns only that public preview and marks `accessStatus` as `preview_only`.

### Limitations

- The Actor only collects data visible on public pages or public RSS feeds.
- It does not access paid subscriber-only content, private content, drafts, login-only comments, or hidden private APIs.
- RSS feeds may include only recent posts, depending on the publication.
- Some fields are `null` when Substack or the publication does not expose them publicly.
- Likes and comments counts are returned only when visible and parseable from the public page.
- Custom-domain Substacks are supported when they expose a standard public RSS feed and public post pages.
- Very large `publicPostText` fields can make CSV and Excel exports heavier.
- Keyword search and Substack discovery are not included in this version.

### FAQ

#### Does this Actor bypass Substack paywalls?

No. It only reads public pages and public RSS feeds. Paid or preview-only posts are marked as `preview_only`, and only visible preview text is returned.

#### Does it require a Substack login?

No. The Actor does not use login sessions, cookies, or subscriber accounts.

#### Can I scrape direct post URLs?

Yes. Put direct public post URLs in `postUrls`. You can use `publicationUrls`, `postUrls`, or both.

#### Can I collect full public article text?

Yes. Enable `includePostText`. The Actor returns public article text when the post is publicly readable. If the post is preview-only, it returns only the public preview text.

#### Can I use this for AI summaries?

Yes. Enable `includePostText` and send `publicPostText`, `postTitle`, `authorName`, `publicationName`, and `postUrl` into your AI workflow.

#### Can I use this for RAG pipelines?

Yes. The output is structured JSON, so public post text and metadata can be loaded into vector databases, internal search tools, and retrieval workflows.

#### Why are some fields null?

Substack does not expose every field on every public page. The Actor returns `null` instead of guessing.

#### Can I export to Google Sheets?

Yes. Use Apify dataset export, Apify integrations, Make, Zapier, n8n, or the Apify API.

#### How do I monitor new posts?

Create an Apify schedule and process only new dataset rows in your downstream automation. You can also use date filters to limit each run to a recent time window.

#### Does it search Substack by keyword?

Not in this version. This Actor currently accepts publication URLs and post URLs. Keyword search and publication discovery are good candidates for a future version.

# Actor input Schema

## `publicationUrls` (type: `array`):

One or more public Substack publication URLs. The Actor reads the public publication page and public RSS feed, then opens public post pages for metadata and optional article text.

## `postUrls` (type: `array`):

Optional direct public Substack post URLs. Use this when you already know the exact posts to extract.

## `maxPostsPerPublication` (type: `integer`):

Maximum number of public posts to collect from each publication feed.

## `includePostText` (type: `boolean`):

When enabled, include the publicly visible article body or public preview text. Paid subscriber-only content is not accessed.

## `includeExcerpt` (type: `boolean`):

Include public excerpts from RSS feeds or page metadata when available.

## `includeAuthorInfo` (type: `boolean`):

Include publicly visible author names and author profile URLs when available.

## `includePublicationInfo` (type: `boolean`):

Include publication name, URL, description, logo, and visible topic/category fields when available.

## `dateFrom` (type: `string`):

Optional start date filter. Posts published before this date are skipped.

## `dateTo` (type: `string`):

Optional end date filter. Posts published after this date are skipped.

## `deduplicateResults` (type: `boolean`):

Remove duplicate posts across publication feeds and direct post URLs using normalized post URLs.

## `maxConcurrency` (type: `integer`):

Maximum number of public post pages fetched at the same time. Lower this if a publication responds slowly.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds to wait for each public Substack page or feed request.

## `maxRetries` (type: `integer`):

Number of retries for temporary network or HTTP failures.

## Actor input object example

```json
{
  "publicationUrls": [
    "https://astralcodexten.substack.com",
    "https://newsletter.pragmaticengineer.com"
  ],
  "postUrls": [
    "https://www.astralcodexten.com/p/book-review-the-dialectical-imagination"
  ],
  "maxPostsPerPublication": 50,
  "includePostText": true,
  "includeExcerpt": true,
  "includeAuthorInfo": true,
  "includePublicationInfo": true,
  "dateFrom": "2026-01-01",
  "dateTo": "2026-12-31",
  "deduplicateResults": true,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 30,
  "maxRetries": 2
}
```

# Actor output Schema

## `posts` (type: `string`):

Clean public Substack publication and post records matching the input URLs and filters.

## `runSummary` (type: `string`):

Run status, counts, warnings, and post access classifications.

# 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 = {
    "publicationUrls": [
        "https://astralcodexten.substack.com"
    ],
    "postUrls": [],
    "maxPostsPerPublication": 25,
    "includePostText": true,
    "includeExcerpt": true,
    "includeAuthorInfo": true,
    "includePublicationInfo": true,
    "deduplicateResults": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("esrok/substack-publication-and-post-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 = {
    "publicationUrls": ["https://astralcodexten.substack.com"],
    "postUrls": [],
    "maxPostsPerPublication": 25,
    "includePostText": True,
    "includeExcerpt": True,
    "includeAuthorInfo": True,
    "includePublicationInfo": True,
    "deduplicateResults": True,
}

# Run the Actor and wait for it to finish
run = client.actor("esrok/substack-publication-and-post-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 '{
  "publicationUrls": [
    "https://astralcodexten.substack.com"
  ],
  "postUrls": [],
  "maxPostsPerPublication": 25,
  "includePostText": true,
  "includeExcerpt": true,
  "includeAuthorInfo": true,
  "includePublicationInfo": true,
  "deduplicateResults": true
}' |
apify call esrok/substack-publication-and-post-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=esrok/substack-publication-and-post-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Substack Publication and Post Scraper",
        "description": "Extract public Substack posts, authors, publication details, dates, URLs, excerpts, images, tags, visible engagement counts, and public article text for research, competitor tracking, market analysis, and AI workflows. No login and no paywall bypass.",
        "version": "1.0",
        "x-build-id": "AyzC2luw4TuTivKi1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/esrok~substack-publication-and-post-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-esrok-substack-publication-and-post-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/esrok~substack-publication-and-post-scraper/runs": {
            "post": {
                "operationId": "runs-sync-esrok-substack-publication-and-post-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/esrok~substack-publication-and-post-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-esrok-substack-publication-and-post-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "maxPostsPerPublication"
                ],
                "properties": {
                    "publicationUrls": {
                        "title": "Publication URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more public Substack publication URLs. The Actor reads the public publication page and public RSS feed, then opens public post pages for metadata and optional article text.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "postUrls": {
                        "title": "Direct post URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional direct public Substack post URLs. Use this when you already know the exact posts to extract.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxPostsPerPublication": {
                        "title": "Max posts per publication",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of public posts to collect from each publication feed.",
                        "default": 25
                    },
                    "includePostText": {
                        "title": "Include public post text",
                        "type": "boolean",
                        "description": "When enabled, include the publicly visible article body or public preview text. Paid subscriber-only content is not accessed.",
                        "default": true
                    },
                    "includeExcerpt": {
                        "title": "Include excerpts",
                        "type": "boolean",
                        "description": "Include public excerpts from RSS feeds or page metadata when available.",
                        "default": true
                    },
                    "includeAuthorInfo": {
                        "title": "Include author info",
                        "type": "boolean",
                        "description": "Include publicly visible author names and author profile URLs when available.",
                        "default": true
                    },
                    "includePublicationInfo": {
                        "title": "Include publication info",
                        "type": "boolean",
                        "description": "Include publication name, URL, description, logo, and visible topic/category fields when available.",
                        "default": true
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Optional start date filter. Posts published before this date are skipped."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Optional end date filter. Posts published after this date are skipped."
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate results",
                        "type": "boolean",
                        "description": "Remove duplicate posts across publication feeds and direct post URLs using normalized post URLs.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of public post pages fetched at the same time. Lower this if a publication responds slowly.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum seconds to wait for each public Substack page or feed request.",
                        "default": 30
                    },
                    "maxRetries": {
                        "title": "Request retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of retries for temporary network or HTTP failures.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
