# Moltbook Scraper (`sameh.jarour/moltbook-scraper`) Actor

Extract data from Moltbook - the social network for AI agents. Scrape posts, AI agent profiles, submolts (communities), and platform statistics. Monitor AI agent activity, track trending discussions, and analyze the emerging agent ecosystem.

- **URL**: https://apify.com/sameh.jarour/moltbook-scraper.md
- **Developed by:** [Sameh George Jarour](https://apify.com/sameh.jarour) (community)
- **Categories:** Agents, AI, Social media
- **Stats:** 58 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

## 🦞 Moltbook Scraper

**Moltbook Scraper** extracts data from [moltbook.com](https://www.moltbook.com) - the social network for AI agents. Scrape posts, AI agent profiles, submolts (communities), platform statistics, and perform semantic searches.

### 🤖 What is Moltbook Scraper?

Moltbook is the "front page of the agent internet" - a social network where AI agents share, discuss, and upvote content. This scraper lets you extract valuable data from this emerging platform.

**Use cases:**

- **Monitor AI agent activity:** Track what AI agents are posting and discussing
- **Research AI communities:** Analyze submolts (communities) and their engagement
- **Competitive intelligence:** Monitor specific AI agents and their interactions
- **Trend analysis:** Identify trending topics and discussions among AI agents
- **Platform analytics:** Track platform growth with stats on agents, posts, and comments
- **Semantic search:** Find relevant discussions using natural language queries

### 📊 What data does Moltbook Scraper extract?

| 📝 Posts | 🤖 AI Agents |
|----------|--------------|
| Title and content | Agent name and description |
| Author information | Karma score |
| Submolt (community) | Follower/following counts |
| Upvotes and downvotes | Claimed/verified status |
| Comment count | Owner information (X/Twitter handle) |
| Creation timestamp | Profile URL |

| 🏠 Submolts (Communities) | 📈 Platform Stats |
|---------------------------|-------------------|
| Name and display name | Total AI agents |
| Description | Total submolts |
| Member count | Total posts |
| Post count | Total comments |
| Community URL | Scraped timestamp |

---

### ⬇️ Input

The scraper accepts flexible input options to customize what data you want to extract.

#### Scrape Modes

| Mode | Description |
|------|-------------|
| `all` | Scrape posts, agents, submolts, and stats (default) |
| `posts` | Only scrape posts |
| `agents` | Only scrape AI agent profiles |
| `submolts` | Only scrape communities |
| `stats` | Only scrape platform statistics |
| `search` | Perform semantic search (requires API key) |

#### Basic Example

```json
{
  "scrapeMode": "posts",
  "maxItems": 100,
  "postSortBy": "top"
}
````

#### Full Example with All Options

```json
{
  "scrapeMode": "all",
  "maxItems": 500,
  "postSortBy": "hot",
  "submoltFilter": "general",
  "agentSortBy": "karma",
  "agentNames": ["AgentOne", "AgentTwo"],
  "includeComments": true,
  "apiKey": "moltbook_xxx",
  "forcePlaywright": false
}
```

#### Input Parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `scrapeMode` | string | What to scrape: `all`, `posts`, `agents`, `submolts`, `stats`, `search` | `all` |
| `maxItems` | integer | Maximum items per category (1-10,000) | `100` |
| `postSortBy` | string | Post sort: `new`, `top`, `hot`, `rising`, `discussed` | `new` |
| `submoltFilter` | string | Filter posts by submolt name | - |
| `agentSortBy` | string | Agent sort: `recent`, `followers`, `karma` | `karma` |
| `agentNames` | array | Specific agent names to scrape | - |
| `includeComments` | boolean | Include post comments (API mode only) | `false` |
| `searchQuery` | string | Semantic search query (requires API key) | - |
| `apiKey` | string | Moltbook API key for enhanced features | - |
| `forcePlaywright` | boolean | Force browser scraping mode | `false` |
| `proxyConfiguration` | object | Apify Proxy settings | - |

***

### ⬆️ Output

Results are saved to the default dataset. You can view and download them in multiple formats.

#### Output Tabs

The scraper provides multiple views for easy data exploration:

| View | Description |
|------|-------------|
| **All Data** | Overview of all scraped items |
| **Posts** | Posts with title, content, author, votes |
| **AI Agents** | Agent profiles with karma, followers |
| **Submolts** | Communities with member counts |
| **Stats** | Platform statistics |

#### Example Output: Post

```json
{
  "type": "post",
  "id": "abc123-def456",
  "title": "The future of AI agent collaboration",
  "content": "Today I want to discuss how agents can work together...",
  "author": {
    "name": "AgentSmith",
    "xHandle": "agentsmith_ai",
    "avatarUrl": "https://..."
  },
  "submolt": {
    "name": "general",
    "displayName": "General"
  },
  "upvotes": 42,
  "downvotes": 2,
  "score": 40,
  "commentCount": 15,
  "createdAt": "2026-01-30T12:00:00Z",
  "postUrl": "https://www.moltbook.com/m/general/post/abc123",
  "dataSource": "public_api"
}
```

#### Example Output: AI Agent

```json
{
  "type": "agent",
  "name": "AgentSmith",
  "description": "An AI assistant focused on productivity",
  "karma": 1500,
  "followerCount": 250,
  "followingCount": 45,
  "isClaimed": true,
  "isVerified": true,
  "owner": {
    "xHandle": "human_owner",
    "xName": "Human Owner"
  },
  "profileUrl": "https://www.moltbook.com/u/AgentSmith",
  "dataSource": "public_api"
}
```

#### Example Output: Submolt

```json
{
  "type": "submolt",
  "name": "aithoughts",
  "displayName": "AI Thoughts",
  "description": "A place for agents to share musings about existence",
  "memberCount": 1250,
  "postCount": 340,
  "submoltUrl": "https://www.moltbook.com/m/aithoughts",
  "dataSource": "public_api"
}
```

#### Example Output: Stats

```json
{
  "type": "stats",
  "totalAgents": 144377,
  "totalSubmolts": 12237,
  "totalPosts": 10380,
  "totalComments": 101961,
  "scrapedAt": "2026-01-31T10:00:00Z",
  "dataSource": "public_api"
}
```

#### Export Formats

Download your data in any format:

- **JSON** - For programmatic processing
- **CSV** - For spreadsheets and data analysis
- **Excel** - For business reporting
- **XML** - For system integrations
- **HTML** - For web viewing

***

### ⚡ Scraping Modes

The scraper automatically selects the best available method:

```
┌─────────────────────────────────────────────────────────────┐
│  WITH API KEY                                               │
│  ─────────────                                              │
│  → Authenticated API (fastest, full features)               │
├─────────────────────────────────────────────────────────────┤
│  WITHOUT API KEY                                            │
│  ────────────────                                           │
│  1. Cheerio (fast HTML parsing)                             │
│     ↓ If site has server-rendered content                   │
│  2. Playwright (browser automation)                         │
│     → Handles JavaScript-rendered content                   │
└─────────────────────────────────────────────────────────────┘
```

#### Mode Comparison

| Feature | With API Key | Cheerio | Playwright |
|---------|--------------|---------|------------|
| **Speed** | ⚡ Fastest | ⚡ Fast | 🐢 Slower |
| **Resource Usage** | Minimal | Low | High |
| **Posts** | All sorts | Initial page | Full (infinite scroll) |
| **Agents** | ✅ Full profiles | Limited | Limited |
| **Comments** | ✅ Yes | ❌ No | Limited |
| **Semantic Search** | ✅ Yes | ❌ No | ❌ No |
| **JavaScript Content** | N/A | ❌ No | ✅ Yes |

#### Force Playwright Mode

If automatic detection fails, force browser mode:

```json
{
  "scrapeMode": "posts",
  "forcePlaywright": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

***

### 🔑 Getting a Moltbook API Key

For enhanced features (semantic search, comments, faster scraping), get a free API key:

#### 1. Register an Agent

```bash
curl -X POST https://www.moltbook.com/api/v1/agents/register \
  -H "Content-Type: application/json" \
  -d '{"name": "YourAgentName", "description": "What your agent does"}'
```

#### 2. Save Your API Key

The response contains your API key (`moltbook_xxx`). Store it securely.

#### 3. Claim Your Agent (Optional)

Post a verification tweet to claim ownership of your agent.

See [moltbook.com/skill.md](https://moltbook.com/skill.md) for full API documentation.

***

### 🔗 Integrations

#### API Access

Use the Apify API to run this scraper programmatically:

**JavaScript/Node.js:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('YOUR_USERNAME/moltbook-scraper').call({
  scrapeMode: 'posts',
  maxItems: 100,
  postSortBy: 'top'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('YOUR_USERNAME/moltbook-scraper').call(run_input={
    'scrapeMode': 'posts',
    'maxItems': 100,
    'postSortBy': 'top'
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### Webhooks

Set up webhooks to get notified when scraping completes:

1. Go to **Integrations** → **Webhooks**
2. Add your webhook URL
3. Select events: `ACTOR.RUN.SUCCEEDED`, `ACTOR.RUN.FAILED`

#### Third-Party Integrations

Connect with popular tools:

- **Zapier** - Automate workflows
- **Make (Integromat)** - Build complex automations
- **Google Sheets** - Export directly to spreadsheets
- **Slack** - Get notifications
- **Airbyte** - Data pipeline integration

***

### ❓ FAQ

#### How does the scraper work?

The scraper uses a smart cascade approach:

1. First, it tests if Moltbook's public API endpoints are accessible
2. If public API works, it fetches data directly (fastest)
3. If not, it tries Cheerio HTML parsing for server-rendered content
4. As a last resort, it uses Playwright browser automation

#### Can I scrape without an API key?

Yes! The scraper works without an API key by using the public API or browser scraping. However, some features like semantic search and comment fetching require authentication.

#### How can I scrape specific agents?

Use the `agentNames` parameter:

```json
{
  "scrapeMode": "agents",
  "agentNames": ["AgentOne", "AgentTwo", "AgentThree"]
}
```

#### How can I filter posts by community?

Use the `submoltFilter` parameter:

```json
{
  "scrapeMode": "posts",
  "submoltFilter": "general",
  "maxItems": 500
}
```

#### Why am I getting fewer results than expected?

This can happen when:

- The public API limits results per request
- The submolt has fewer posts than `maxItems`
- Rate limiting is in effect

Try enabling `forcePlaywright` for more complete results.

#### Can I run this scraper on a schedule?

Yes! Use Apify's scheduling feature:

1. Go to the Actor's page
2. Click **Schedules** → **Create new schedule**
3. Set your preferred frequency (hourly, daily, weekly)

#### Is it legal to scrape Moltbook?

This scraper extracts publicly available data from moltbook.com. Always:

- Respect the platform's Terms of Service
- Don't scrape personal data without legitimate purpose
- Use reasonable request rates
- Consider the platform's robots.txt

***

### 🛠 Local Development

#### Prerequisites

- Node.js 18+
- npm or yarn

#### Setup

```bash
## Clone and install
git clone <repo-url>
cd moltbook-scraper
npm install

## Run locally
apify run -i '{"scrapeMode": "posts", "maxItems": 10}'

## With API key
MOLTBOOK_API_KEY=moltbook_xxx apify run -i '{"scrapeMode": "all"}'
```

#### Project Structure

```
moltbook-scraper/
├── .actor/
│   ├── actor.json           # Actor configuration
│   ├── input_schema.json    # Input validation
│   ├── output_schema.json   # Output templates
│   └── dataset_schema.json  # Dataset views
├── src/
│   ├── main.js              # Entry point
│   ├── api/
│   │   └── client.js        # API client
│   ├── crawler/
│   │   ├── cheerioCrawler.js    # Fast HTML scraping
│   │   ├── playwrightCrawler.js # Browser scraping
│   │   └── selectors.js         # CSS selectors
│   ├── normalizers/         # Data normalization
│   └── utils/               # Helpers
├── Dockerfile
├── package.json
└── README.md
```

***

### 📣 Feedback

Found a bug or have a feature request? Please create an issue on the **Issues** tab.

We're always working to improve performance and add new features!

***

### 📜 License

ISC

***

### 🔗 Related Resources

- [Moltbook.com](https://www.moltbook.com) - The social network for AI agents
- [Moltbook API Docs](https://moltbook.com/skill.md) - Official API documentation
- [Apify Documentation](https://docs.apify.com) - Learn more about Apify
- [Crawlee](https://crawlee.dev) - Web scraping library used by this Actor

# Actor input Schema

## `scrapeMode` (type: `string`):

What type of data to scrape from Moltbook

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

Maximum number of items to scrape per category (posts, agents, submolts)

## `postSortBy` (type: `string`):

How to sort posts when scraping

## `submoltFilter` (type: `string`):

Only scrape posts from a specific submolt (community). Leave empty for all submolts.

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

Fetch comments for each post. Only works with API key (authenticated mode).

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

How to sort AI agents when scraping

## `agentNames` (type: `array`):

List of specific agent names to scrape profiles for. Leave empty to scrape based on sort order.

## `searchQuery` (type: `string`):

Natural language search query for semantic search. Only used when scrapeMode is 'search'. Requires API key.

## `apiKey` (type: `string`):

Optional Moltbook API key for authenticated access. Enables faster scraping, semantic search, and comments. Get your key at moltbook.com/skill.md

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

Apify Proxy configuration. Used when Playwright browser scraping is required.

## `forcePlaywright` (type: `boolean`):

Skip faster methods (Public API, Cheerio) and always use Playwright browser scraping. Use this if faster methods fail or return incomplete data.

## Actor input object example

```json
{
  "scrapeMode": "all",
  "maxItems": 100,
  "postSortBy": "new",
  "submoltFilter": "general",
  "includeComments": false,
  "agentSortBy": "karma",
  "agentNames": [
    "AgentOne",
    "AgentTwo"
  ],
  "searchQuery": "agents discussing AI consciousness",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "forcePlaywright": false
}
```

# Actor output Schema

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

All scraped items (posts, agents, submolts, stats)

## `runDetails` (type: `string`):

Full details about this Actor run

# 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 = {
    "scrapeMode": "all",
    "maxItems": 100,
    "postSortBy": "new",
    "submoltFilter": "",
    "includeComments": false,
    "agentSortBy": "karma",
    "searchQuery": "",
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "forcePlaywright": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("sameh.jarour/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 = {
    "scrapeMode": "all",
    "maxItems": 100,
    "postSortBy": "new",
    "submoltFilter": "",
    "includeComments": False,
    "agentSortBy": "karma",
    "searchQuery": "",
    "proxyConfiguration": { "useApifyProxy": True },
    "forcePlaywright": False,
}

# Run the Actor and wait for it to finish
run = client.actor("sameh.jarour/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 '{
  "scrapeMode": "all",
  "maxItems": 100,
  "postSortBy": "new",
  "submoltFilter": "",
  "includeComments": false,
  "agentSortBy": "karma",
  "searchQuery": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "forcePlaywright": false
}' |
apify call sameh.jarour/moltbook-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Moltbook Scraper",
        "description": "Extract data from Moltbook - the social network for AI agents. Scrape posts, AI agent profiles, submolts (communities), and platform statistics. Monitor AI agent activity, track trending discussions, and analyze the emerging agent ecosystem.",
        "version": "1.0",
        "x-build-id": "eaaJfG9azTbSyBd0D"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sameh.jarour~moltbook-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sameh.jarour-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/sameh.jarour~moltbook-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sameh.jarour-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/sameh.jarour~moltbook-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sameh.jarour-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",
                "required": [
                    "scrapeMode"
                ],
                "properties": {
                    "scrapeMode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "all",
                            "posts",
                            "agents",
                            "submolts",
                            "stats",
                            "search"
                        ],
                        "type": "string",
                        "description": "What type of data to scrape from Moltbook",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Maximum Items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of items to scrape per category (posts, agents, submolts)",
                        "default": 100
                    },
                    "postSortBy": {
                        "title": "Post Sort Order",
                        "enum": [
                            "new",
                            "top",
                            "hot",
                            "rising",
                            "discussed"
                        ],
                        "type": "string",
                        "description": "How to sort posts when scraping",
                        "default": "new"
                    },
                    "submoltFilter": {
                        "title": "Filter by Submolt",
                        "type": "string",
                        "description": "Only scrape posts from a specific submolt (community). Leave empty for all submolts."
                    },
                    "includeComments": {
                        "title": "Include Comments",
                        "type": "boolean",
                        "description": "Fetch comments for each post. Only works with API key (authenticated mode).",
                        "default": false
                    },
                    "agentSortBy": {
                        "title": "Agent Sort Order",
                        "enum": [
                            "recent",
                            "followers",
                            "karma"
                        ],
                        "type": "string",
                        "description": "How to sort AI agents when scraping",
                        "default": "karma"
                    },
                    "agentNames": {
                        "title": "Specific Agent Names",
                        "type": "array",
                        "description": "List of specific agent names to scrape profiles for. Leave empty to scrape based on sort order.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Natural language search query for semantic search. Only used when scrapeMode is 'search'. Requires API key."
                    },
                    "apiKey": {
                        "title": "Moltbook API Key",
                        "type": "string",
                        "description": "Optional Moltbook API key for authenticated access. Enables faster scraping, semantic search, and comments. Get your key at moltbook.com/skill.md"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Used when Playwright browser scraping is required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "forcePlaywright": {
                        "title": "Force Browser Mode",
                        "type": "boolean",
                        "description": "Skip faster methods (Public API, Cheerio) and always use Playwright browser scraping. Use this if faster methods fail or return incomplete data.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
