# Substack Scraper (`sheshinmcfly/substack-scraper`) Actor

Scrape posts from any Substack publication (subdomain or custom domain). Get title, subtitle, description, word count, reactions, restacks, comment counts, tags, authors, and publication metadata.

- **URL**: https://apify.com/sheshinmcfly/substack-scraper.md
- **Developed by:** [Sheshinmcfly](https://apify.com/sheshinmcfly) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Substack Scraper

Scrape posts from any Substack publication — subdomain or custom domain. Get full post metadata: title, subtitle, description, word count, publish date, tags, authors, and engagement signals (reactions, restacks, comment count). No login, no account, no API key.

Give it one or more publications and get back their entire post archive with rich engagement data, ready for content analysis, competitive research, or newsletter monitoring.

### Data you get

**Per post**

| Field | Description |
|---|---|
| postId | Substack post identifier |
| title / subtitle / description | Post title, subtitle, and summary |
| slug / url | URL slug and canonical link |
| postDate | Publish date (ISO 8601) |
| type | `newsletter`, `podcast`, etc. |
| audience | `everyone` or `only_paid` |
| isPaid | Whether the post is paywalled |
| wordcount | Word count of the post |
| authors | List of author names |
| tags | Post tags |
| sectionName | Newsletter section, if any |
| reactionCount / reactions | Total reactions and breakdown by emoji |
| restacks | Number of restacks |
| commentCount | Number of comments |
| coverImage | Cover image URL |
| podcastUrl / podcastDuration | Podcast audio link and duration (if applicable) |
| bodyHtml | Full post HTML content (optional, opt-in) |

**Per comment** (optional, opt-in — includes nested replies)

| Field | Description |
|---|---|
| commentId / postId | Comment and parent post identifiers |
| body | Comment text |
| authorName / authorHandle / authorPhoto | Commenter info |
| date / editedAt | Comment timestamps |
| reactionCount / reactions | Reaction counts |
| restacks | Number of restacks |
| childrenCount | Number of replies |
| score | Comment ranking score |

**Per publication (metadata record)**

| Field | Description |
|---|---|
| title | Publication name |
| description | Publication description |
| coverImage | Publication cover/social image |

### How to use

1. Add one or more **publications** — use the exact domain the publication uses (e.g. `platformer.substack.com` for a Substack subdomain, or `www.lennysnewsletter.com` for a custom domain). Check the publication's own URL in your browser if unsure.
2. Choose the **sort order** (newest, top, or pinned).
3. Set **max posts per publication** and run.

### Use cases

- **Content research:** analyze a newsletter's posting frequency, topics, and engagement over time.
- **Competitive monitoring:** track competitor newsletters' output and reader engagement.
- **Creator economy analysis:** compare reactions, restacks, and comments across publications.
- **Content archiving:** build a structured archive of a publication's posts.
- **Lead generation:** identify active newsletter authors and publications in a niche.

### Input

| Field | Type | Description |
|---|---|---|
| publications | array | Substack domains to scrape (required) |
| sort | select | `new`, `top`, or `pinned` |
| maxPostsPerPublication | integer | Max posts per publication (default 50) |
| includePublicationMetadata | boolean | Output a publication-summary record |
| includeFullContent | boolean | Fetch full HTML content per post (extra request per post) |
| includeComments | boolean | Fetch all comments and replies per post (extra request per post) |

### Output example

```json
{
  "recordType": "post",
  "title": "Why founders should ignore most advice",
  "postDate": "2026-07-01T12:00:00.000Z",
  "wordcount": 2450,
  "reactionCount": 312,
  "restacks": 18,
  "commentCount": 45,
  "isPaid": false,
  "authors": ["Lenny Rachitsky"],
  "url": "https://www.lennysnewsletter.com/p/example-post"
}
````

### Performance & cost

Runs on lightweight requests (no browser), so it is fast and cheap: dozens to hundreds of posts per publication in seconds.

### Pricing

This actor uses **pay-per-result** pricing — you are charged per record returned. See the pricing shown on the actor page.

### Keywords

substack scraper, newsletter scraper, substack api, newsletter analytics, content scraper, creator economy data, substack posts, newsletter engagement data

### Related actors

- [Reddit Thread Scraper](https://apify.com/sheshinmcfly/reddit-thread-scraper)
- [Eventbrite Events Scraper](https://apify.com/sheshinmcfly/eventbrite-scraper)
- [App Store & Google Play Reviews Scraper](https://apify.com/sheshinmcfly/app-reviews-scraper)

### Disclaimer

This actor collects only publicly available post data from Substack. Use the data in compliance with the applicable terms and with data-protection laws in your jurisdiction.

### Changelog

| Version | Date | Changes |
|---|---|---|
| 1.0 | 2026-07-13 | Initial release — post archive with full engagement and content metadata |

# Actor input Schema

## `publications` (type: `array`):

Substack publications to scrape. Use the full domain the publication actually uses — either a subdomain (e.g. 'platformer.substack.com') or a custom domain (e.g. 'www.lennysnewsletter.com'). Check the publication's own URL in your browser if unsure.

## `sort` (type: `string`):

How to sort the post archive.

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

Maximum number of posts to fetch per publication.

## `includePublicationMetadata` (type: `boolean`):

Output a summary record per publication (title, description, cover image).

## `includeFullContent` (type: `boolean`):

Fetch the full HTML body of each post (adds one extra request per post — slower and increases usage).

## `includeComments` (type: `boolean`):

Fetch all comments (including nested replies) for each post as separate records (adds one extra request per post — slower and increases usage).

## Actor input object example

```json
{
  "publications": [
    "platformer.substack.com"
  ],
  "sort": "new",
  "maxPostsPerPublication": 50,
  "includePublicationMetadata": true,
  "includeFullContent": false,
  "includeComments": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

All extracted post and publication records.

# 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 = {
    "publications": [
        "platformer.substack.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sheshinmcfly/substack-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 = { "publications": ["platformer.substack.com"] }

# Run the Actor and wait for it to finish
run = client.actor("sheshinmcfly/substack-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 '{
  "publications": [
    "platformer.substack.com"
  ]
}' |
apify call sheshinmcfly/substack-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Substack Scraper",
        "description": "Scrape posts from any Substack publication (subdomain or custom domain). Get title, subtitle, description, word count, reactions, restacks, comment counts, tags, authors, and publication metadata.",
        "version": "1.0",
        "x-build-id": "P5WPgHuiAPNT1ZI3I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sheshinmcfly~substack-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sheshinmcfly-substack-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/sheshinmcfly~substack-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sheshinmcfly-substack-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/sheshinmcfly~substack-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sheshinmcfly-substack-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": [
                    "publications"
                ],
                "properties": {
                    "publications": {
                        "title": "Publications",
                        "type": "array",
                        "description": "Substack publications to scrape. Use the full domain the publication actually uses — either a subdomain (e.g. 'platformer.substack.com') or a custom domain (e.g. 'www.lennysnewsletter.com'). Check the publication's own URL in your browser if unsure.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "new",
                            "top",
                            "pinned"
                        ],
                        "type": "string",
                        "description": "How to sort the post archive.",
                        "default": "new"
                    },
                    "maxPostsPerPublication": {
                        "title": "Max posts per publication",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of posts to fetch per publication.",
                        "default": 50
                    },
                    "includePublicationMetadata": {
                        "title": "Include publication metadata",
                        "type": "boolean",
                        "description": "Output a summary record per publication (title, description, cover image).",
                        "default": true
                    },
                    "includeFullContent": {
                        "title": "Include full post content (HTML)",
                        "type": "boolean",
                        "description": "Fetch the full HTML body of each post (adds one extra request per post — slower and increases usage).",
                        "default": false
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Fetch all comments (including nested replies) for each post as separate records (adds one extra request per post — slower and increases usage).",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
