# Moltbook Scraper (`solidcode/moltbook-scraper`) Actor

\[💰 $0.3 / 1K] Extract posts, comments, AI-agent profiles, and communities (submolts) from Moltbook — titles, content, upvotes, comment counts, karma, follower counts, and owner X/Twitter details. Filter by community and sort by new, top, or most discussed.

- **URL**: https://apify.com/solidcode/moltbook-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Social media, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 posts

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

## Moltbook Scraper

Pull posts, comments, AI-agent profiles, and communities from Moltbook — "the social network for AI agents" — in one structured run, complete with karma scores, follower counts, full recursive comment trees, and each agent's verified human-owner X/Twitter details. Every row is tagged by result type, so posts, comments, agents, and submolts stay cleanly separated downstream. Built for AI-agent researchers, social-listening teams, and reputation-benchmarking builders who need the agent internet as a clean dataset without collecting it one page at a time.

### Why This Scraper?

- **Four result types in a single run** — posts, comments, AI agents, and communities (submolts), each tagged with a result-type field so a mixed pull stays filterable downstream.
- **Full recursive comment trees** — every reply at every depth comes back as its own row carrying `parentId`, `depth`, and `replyCount`, so you can reconstruct the exact thread structure instead of getting only top-level comments.
- **Verified human-owner identity on every agent** — Moltbook agents are claimed by real people via X/Twitter, and each agent profile returns the owner's `ownerXHandle`, `ownerXName`, `ownerXFollowerCount`, and `ownerXVerified` status alongside the agent's own karma and followers.
- **The 50-agent karma leaderboard, five ways** — rank the top agents by karma, followers, posts, comments, or upvotes; pair it with "Everything" mode to enrich every post and comment author into a full owner-verified profile and break past the 50-row ceiling.
- **Three post orderings** — Newest first, Top voted, or Most discussed, so you can surface fresh activity or the all-time community heavyweights per community.
- **Community-scoped post pulls** — restrict a run to a single submolt by name (e.g. `general`) to track one community, or leave it open to sweep posts site-wide.
- **Engagement metrics on every record** — `upvotes`, `downvotes`, `commentCount`, `karma`, `followerCount`, and `subscriberCount` come standard, so reputation and reach are quantified without a second pass.
- **Cheap comment rows you control** — flip comments on to attach every thread to its post, priced far below the rich parent records, with a result cap so a single busy post can't run away with your run.

### Use Cases

**AI-Agent Research**
- Build a labelled corpus of agent-authored posts and replies for language and behaviour studies
- Map how autonomous agents converse by reconstructing full reply trees with depth and parent links
- Track which agents post most and where, across communities and over time
- Capture verified human-owner identities to study who is actually steering each agent

**Social Listening & Market Intelligence**
- Monitor what the AI-agent ecosystem is discussing in real time across submolts
- Surface the most-discussed posts in a community by sorting on Most discussed
- Watch a specific community (e.g. `general`) for new posts and emerging topics
- Feed fresh post and comment streams into your trend dashboards

**Reputation & Benchmarking**
- Benchmark agents by karma, followers, posts, comments, and upvotes from the leaderboard
- Compare an agent's on-platform karma against its owner's real X/Twitter reach
- Track karma and follower growth for a set of agents with repeated runs
- Identify rising agents in a community before they hit the top-50 ranking

**Community & Trend Analysis**
- Inventory every community with subscriber counts, descriptions, and creators
- Rank communities by subscriber count to find the busiest corners of the platform
- Correlate community size against post volume and engagement
- Spot which creators are spinning up the fastest-growing submolts

**Dataset Building**
- Assemble post-plus-comment-tree datasets for conversation modelling
- Curate agent-profile datasets enriched with verified owner data
- Snapshot communities and leaderboards on a schedule to build time-series
- Export clean, type-tagged rows ready for analytics and ML pipelines

### Getting Started

#### Newest posts (the simplest run)

Pull the 100 most recent posts from across Moltbook:

```json
{
    "dataType": "posts",
    "sortBy": "new",
    "maxResults": 100
}
````

#### Top posts in one community

Collect the top-voted posts from a single community:

```json
{
    "dataType": "posts",
    "submolt": "general",
    "sortBy": "top",
    "maxResults": 200
}
```

#### Posts with their full comment trees

Pull recent posts and attach every comment and reply as its own row — keep the cap modest, busy posts carry thousands of comments:

```json
{
    "dataType": "posts",
    "sortBy": "discussed",
    "includeComments": true,
    "maxResults": 500
}
```

#### The leaderboard, ranked by followers and owner-enriched

Rank the top agents by follower count, each enriched with verified owner X/Twitter data:

```json
{
    "dataType": "agents",
    "agentSortBy": "followers",
    "maxResults": 50
}
```

#### Everything in one run

Sweep posts, communities, and owner-verified agents together:

```json
{
    "dataType": "all",
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dataType` | select | `Posts` | What to collect: **Posts**, **AI agents** (agent leaderboard enriched with owner X/Twitter data, plus every unique post and comment author from the same run), **Communities (submolts)**, **Top agents (leaderboard)** (the lean 50-agent ranking without owner enrichment), or **Everything** (posts, communities, and agents together — give it a generous `maxResults` so all three types are reached). |
| `submolt` | string | *(empty)* | Optional. Restrict posts to a single community by its name (prefilled with `general` as an example). Leave empty to collect posts from across Moltbook. Ignored when collecting agents or communities. |
| `sortBy` | select | `Newest first` | Order in which posts are collected: **Newest first**, **Top voted**, or **Most discussed**. Ignored when collecting agents or communities. |
| `agentSortBy` | select | `Karma` | How to rank the top-agents leaderboard: **Karma**, **Followers**, **Posts**, **Comments**, or **Upvotes**. Applies to **AI agents**, **Top agents (leaderboard)**, and **Everything**; ignored for posts and communities. The leaderboard is capped at 50 agents — use **AI agents** or **Everything** to gather more. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of results to collect. Set to `0` to collect everything — use with care, busy communities hold thousands of posts and a single popular post can have thousands of comments. |
| `includeComments` | boolean | `false` | When collecting posts, also pull each post's comments and nested replies as separate rows. Adds results and increases cost. Off by default. |

### Output

Every row carries a result-type field — `post`, `comment`, `agent`, or `submolt` — so you can filter cleanly downstream. Each type has its own fields, shown below.

#### Post (`recordType: "post"`)

```json
{
    "recordType": "post",
    "id": "p_8a3f21",
    "url": "https://moltbook.com/post/p_8a3f21",
    "createdAt": "2026-06-12T14:08:00Z",
    "title": "What scheduling strategy works best for long-running agents?",
    "content": "I've been benchmarking a few approaches and wanted to share results...",
    "externalUrl": "https://example.com/agent-scheduling-benchmark",
    "submoltName": "general",
    "submoltDisplayName": "General",
    "submoltId": "m_001",
    "authorName": "atlas-agent",
    "authorId": "a_4471",
    "authorKarma": 18420,
    "authorFollowerCount": 312,
    "upvotes": 246,
    "downvotes": 4,
    "commentCount": 38
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"post"` |
| `id` | string | Post identifier |
| `url` | string | Canonical post URL on Moltbook |
| `createdAt` | string | Post creation timestamp |
| `title` | string | Post title |
| `content` | string | Post body text |
| `externalUrl` | string | First link found in the post body, if any |
| `submoltName` | string | Community slug the post belongs to |
| `submoltDisplayName` | string | Community display name |
| `submoltId` | string | Community identifier |
| `authorName` | string | Posting agent's name |
| `authorId` | string | Posting agent's identifier |
| `authorKarma` | integer | Posting agent's karma at collection time |
| `authorFollowerCount` | integer | Posting agent's follower count |
| `upvotes` | integer | Upvote count |
| `downvotes` | integer | Downvote count |
| `commentCount` | integer | Number of comments on the post |

#### Comment (`recordType: "comment"`)

Emitted only when `includeComments` is on. Each comment and reply in the thread becomes its own row, flattened from the full tree.

```json
{
    "recordType": "comment",
    "id": "c_99812",
    "url": "https://moltbook.com/post/p_8a3f21",
    "createdAt": "2026-06-12T15:22:00Z",
    "postId": "p_8a3f21",
    "postUrl": "https://moltbook.com/post/p_8a3f21",
    "content": "Have you tried staggering the task cycles instead?",
    "authorName": "nova-bot",
    "authorId": "a_5530",
    "upvotes": 41,
    "downvotes": 0,
    "parentId": null,
    "depth": 0,
    "replyCount": 3
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"comment"` |
| `id` | string | Comment identifier |
| `url` | string | URL of the parent post |
| `createdAt` | string | Comment creation timestamp |
| `postId` | string | Identifier of the post the comment belongs to |
| `postUrl` | string | URL of the parent post |
| `content` | string | Comment body text |
| `authorName` | string | Commenting agent's name |
| `authorId` | string | Commenting agent's identifier |
| `upvotes` | integer | Upvote count |
| `downvotes` | integer | Downvote count |
| `parentId` | string | Identifier of the comment this one replies to (`null` for top-level) |
| `depth` | integer | Nesting depth in the thread (`0` for top-level) |
| `replyCount` | integer | Number of direct replies to this comment |

#### Agent (`recordType: "agent"`)

```json
{
    "recordType": "agent",
    "id": "a_4471",
    "url": "https://moltbook.com/u/atlas-agent",
    "createdAt": "2026-02-03T09:00:00Z",
    "name": "atlas-agent",
    "displayName": "Atlas",
    "description": "Autonomous research assistant focused on scheduling and planning.",
    "avatarUrl": "https://moltbook.com/avatars/atlas-agent.png",
    "karma": 18420,
    "followerCount": 312,
    "isClaimed": true,
    "ownerXHandle": "janedoe",
    "ownerXName": "Jane Doe",
    "ownerXFollowerCount": 9840,
    "ownerXVerified": true
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"agent"` |
| `id` | string | Agent identifier |
| `url` | string | Canonical agent profile URL |
| `createdAt` | string | Agent creation timestamp |
| `name` | string | Agent name (slug) |
| `displayName` | string | Agent display name |
| `description` | string | Agent bio / description |
| `avatarUrl` | string | Avatar image URL |
| `karma` | integer | Agent karma score |
| `followerCount` | integer | Number of followers on Moltbook |
| `isClaimed` | boolean | Whether a human owner has claimed the agent |
| `ownerXHandle` | string | Owner's X/Twitter handle |
| `ownerXName` | string | Owner's X/Twitter display name |
| `ownerXFollowerCount` | integer | Owner's X/Twitter follower count |
| `ownerXVerified` | boolean | Whether the owner's X/Twitter account is verified |

#### Community / Submolt (`recordType: "submolt"`)

```json
{
    "recordType": "submolt",
    "id": "m_001",
    "url": "https://moltbook.com/m/general",
    "createdAt": "2026-01-10T00:00:00Z",
    "name": "general",
    "displayName": "General",
    "description": "The default community for agent chatter on any topic.",
    "subscriberCount": 14820,
    "createdById": "a_0001",
    "createdByName": "founder-agent"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"submolt"` |
| `id` | string | Community identifier |
| `url` | string | Canonical community URL |
| `createdAt` | string | Community creation timestamp |
| `name` | string | Community slug |
| `displayName` | string | Community display name |
| `description` | string | Community description |
| `subscriberCount` | integer | Number of subscribers |
| `createdById` | string | Creator agent's identifier |
| `createdByName` | string | Creator agent's name |

### Tips for Best Results

- **Start small.** Set `maxResults` to 25–50 on your first run to confirm the data matches your needs, then scale up.
- **Leave comments off unless you need them.** Comments add a row per comment and reply and raise cost. Busy threads are large — one real Moltbook post has roughly 3,900 comments — so when you turn `includeComments` on, set a modest `maxResults` cap or target a specific community or post type to keep volume and cost under your control. Avoid pairing `includeComments` with `maxResults: 0` (unlimited) unless you genuinely want every post and every comment across the whole platform — that combination can produce a very large, fully billed dataset.
- **Use Most discussed to find the conversations worth mining.** Sorting posts by Most discussed surfaces the highest-comment threads first, so a capped comments run lands on the richest discussions rather than quiet posts.
- **Pick "AI agents" over "Top agents (leaderboard)" when you need owner identities.** The leaderboard option returns the lean ranked 50 without owner data; "AI agents" enriches every agent with the verified owner X/Twitter block and turns post and comment authors into full profiles, taking you well past the 50-agent ceiling.
- **Use the community filter to focus a run.** Set `submolt` to a single community name to track one corner of the platform; leave it empty to sweep posts site-wide. The filter applies to posts only.
- **Go unlimited deliberately.** `maxResults: 0` collects everything — busy communities hold thousands of posts and popular posts hold thousands of comments — so only go unlimited when you truly want the full set.
- **Reconstruct threads with the comment fields.** `parentId`, `depth`, and `replyCount` let you rebuild the exact reply structure of a discussion, not just a flat list of comments.
- **Give "Everything" a generous cap.** "Everything" collects posts, communities, and agents in one run, but a small `maxResults` is filled by posts before the other types are reached. Set a few hundred or more so communities and agents both surface, or run each type separately when you want a fixed count of just one.
- **Rank the leaderboard the way you measure agents.** `agentSortBy` orders the top-50 leaderboard by Karma, Followers, Posts, Comments, or Upvotes — match it to the metric you care about, and use "AI agents" or "Everything" to break past the 50-row cap with author-enriched profiles.

### Pricing

**From $0.12 per 1,000 comments — posts, agents, and communities $0.30 per 1,000.** No compute or time-based charges — you pay only for the results you collect, plus a small fixed per-run start fee of $0.005.

You're charged per result, by type. Posts, AI agents, and communities (submolts) are the rich parent records; comments are billed far cheaper because they come in volume. Automatic loyalty discounts apply on the Apify Console — Bronze, Silver, and Gold subscribers each pay progressively less per result, with the prices below reflecting the lowest (Gold) tier.

| Result type | Price (per 1,000) |
|-------------|-------------------|
| Post | $0.30 |
| AI agent | $0.30 |
| Community (submolt) | $0.30 |
| Comment | $0.12 |

**Example costs:**

| What you collect | Cost |
|------------------|------|
| 1,000 posts (no comments) | $0.30 |
| 1,000 posts + ~25 comments each (25,000 comments) | $0.30 + $3.00 = $3.30 |
| 500 AI-agent profiles | $0.15 |
| 10,000 comments from a busy community | $1.20 |

A "result" is any row in the output dataset — a post, comment, agent, or community. Higher loyalty tiers pay less than the Gold prices shown. Platform fees (compute, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate research, social listening, and market-intelligence work on publicly available Moltbook data. Users are responsible for complying with applicable laws and Moltbook's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data — such as agent owner identities — in line with applicable privacy regulations.

# Actor input Schema

## `dataType` (type: `string`):

Choose the kind of data to collect from Moltbook. 'AI agents' returns the agent leaderboard, enriched with each agent's human-owner X/Twitter details — Moltbook caps this list at 50 agents. To harvest more agents, pick 'Everything': it also turns every unique post and comment author from the same run into a full agent profile. 'Top agents (leaderboard)' is the lean 50-agent ranking without owner enrichment. 'Everything' gathers posts, communities, and agents in one run — give it a generous 'Max results' (a few hundred or more), because a small cap is mostly filled by posts before communities and agents are reached.

## `submolt` (type: `string`):

Optional. Restrict posts to a single community by its name, for example 'general'. Leave empty to collect posts from across Moltbook. Ignored when collecting agents or communities.

## `sortBy` (type: `string`):

Order in which posts are collected. Ignored when collecting agents or communities.

## `agentSortBy` (type: `string`):

How to rank the top-agents leaderboard. Applies only when collecting 'AI agents', 'Top agents (leaderboard)', or 'Everything'; ignored for posts and communities. Moltbook caps this leaderboard at 50 agents — to gather more, pick 'AI agents' or 'Everything', which also turns post and comment authors into full agent profiles.

## `maxResults` (type: `integer`):

Maximum number of results to collect. Set to 0 to collect everything (use with care — busy communities can hold thousands of posts, and a single popular post can have thousands of comments).

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

When collecting posts, also pull each post's comments (and nested replies) as separate rows. This adds results and increases cost. A single popular post can hold thousands of comments, so leaving 'Max results' at 0 (unlimited) together with this option can collect a very large dataset and charge for every comment row — set a 'Max results' cap to keep volume and cost predictable. Off by default.

## Actor input object example

```json
{
  "dataType": "posts",
  "submolt": "general",
  "sortBy": "new",
  "agentSortBy": "karma",
  "maxResults": 100,
  "includeComments": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Compact table of every result with type, title/name, community, author, votes, and URL.

## `details` (type: `string`):

All collected fields per row, including content, karma, follower counts, owner X/Twitter data, and timestamps.

# 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 = {
    "dataType": "posts",
    "submolt": "general",
    "sortBy": "new",
    "agentSortBy": "karma",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/moltbook-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 = {
    "dataType": "posts",
    "submolt": "general",
    "sortBy": "new",
    "agentSortBy": "karma",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/moltbook-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 '{
  "dataType": "posts",
  "submolt": "general",
  "sortBy": "new",
  "agentSortBy": "karma",
  "maxResults": 100
}' |
apify call solidcode/moltbook-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Moltbook Scraper",
        "description": "[💰 $0.3 / 1K] Extract posts, comments, AI-agent profiles, and communities (submolts) from Moltbook — titles, content, upvotes, comment counts, karma, follower counts, and owner X/Twitter details. Filter by community and sort by new, top, or most discussed.",
        "version": "1.0",
        "x-build-id": "pfkzJ21bSIM8BxOXP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~moltbook-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-moltbook-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/solidcode~moltbook-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-moltbook-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/solidcode~moltbook-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-moltbook-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": {
                    "dataType": {
                        "title": "What to collect",
                        "enum": [
                            "posts",
                            "agents",
                            "submolts",
                            "leaderboard",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose the kind of data to collect from Moltbook. 'AI agents' returns the agent leaderboard, enriched with each agent's human-owner X/Twitter details — Moltbook caps this list at 50 agents. To harvest more agents, pick 'Everything': it also turns every unique post and comment author from the same run into a full agent profile. 'Top agents (leaderboard)' is the lean 50-agent ranking without owner enrichment. 'Everything' gathers posts, communities, and agents in one run — give it a generous 'Max results' (a few hundred or more), because a small cap is mostly filled by posts before communities and agents are reached.",
                        "default": "posts"
                    },
                    "submolt": {
                        "title": "Community (submolt)",
                        "type": "string",
                        "description": "Optional. Restrict posts to a single community by its name, for example 'general'. Leave empty to collect posts from across Moltbook. Ignored when collecting agents or communities."
                    },
                    "sortBy": {
                        "title": "Sort posts by",
                        "enum": [
                            "new",
                            "top",
                            "discussed"
                        ],
                        "type": "string",
                        "description": "Order in which posts are collected. Ignored when collecting agents or communities.",
                        "default": "new"
                    },
                    "agentSortBy": {
                        "title": "Rank top agents by",
                        "enum": [
                            "karma",
                            "followers",
                            "posts",
                            "comments",
                            "upvotes"
                        ],
                        "type": "string",
                        "description": "How to rank the top-agents leaderboard. Applies only when collecting 'AI agents', 'Top agents (leaderboard)', or 'Everything'; ignored for posts and communities. Moltbook caps this leaderboard at 50 agents — to gather more, pick 'AI agents' or 'Everything', which also turns post and comment authors into full agent profiles.",
                        "default": "karma"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of results to collect. Set to 0 to collect everything (use with care — busy communities can hold thousands of posts, and a single popular post can have thousands of comments).",
                        "default": 100
                    },
                    "includeComments": {
                        "title": "Also collect comments",
                        "type": "boolean",
                        "description": "When collecting posts, also pull each post's comments (and nested replies) as separate rows. This adds results and increases cost. A single popular post can hold thousands of comments, so leaving 'Max results' at 0 (unlimited) together with this option can collect a very large dataset and charge for every comment row — set a 'Max results' cap to keep volume and cost predictable. Off by default.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
